由于手比较懒，对J2ME的描述不是很详细，还望多包涵。废话不多说，请看下文：

1. 平台比较

J2me:
开发平台

Android:

操作系统

2. 工程结构比较（源代码，资源文件夹，图片，数据）

J2me:

Res：资源文件

Src：源代码

Android:

Src：源代码

Res\drawable：图片

Res\raw：声音

Res\values：字符串

Assets：数据文件

3. 安装包比较

J2me:

Jad,jar

Android:

apk

4. 代码结构比较

J2me:

MIDlet，Canvas

Android:

Activity，View

都采用继承的方式，都只有一个MIDlet/Activity，一般都只有一个Canvas/View

5. 代码细节比较

l 全屏设置

J2me:

在Canvas类中调用SetFullScreenMode(Boolean)

Android:

在Activity类中调用

//设定全屏显示

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

WindowManager.LayoutParams.FLAG_FULLSCREEN);

requestWindowFeature(Window.FEATURE_NO_TITLE);

2 获得屏幕尺寸

J2me:

Canvas类的getHeight()和getWidth()方法

Android:

int screenWidth,screenHeight;

WindowManager windowManager = getWindowManager();

Display display = windowManager.getDefaultDisplay();

screenWidth = display.getWidth();

screenHeight = display.getHeight();

3 Display

J2me:

Display dis=Display.getDisplay(MIDlet);

Android:

Display display = windowManager.getDefaultDisplay();

4 画布类

J2me:

Canvas

Android:

继承View类，定义构造方法：

public MyView(Context context)

{

super(context);

}

5 屏幕绘制方法

J2me:

Paint(Graphics)

Android:

void onDraw(Canvas g)

6 Graphics

J2me:

Android:

7 Image的创建

J2me:

Image.createImage(path);

Android:

img = BitmapFactory.decodeResource(getResources(),R.drawable.map0);

8 Font的创建，Font使用，字体设置

J2me:

Android:

9 drawImage

J2me:

Android:

public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint)

多个重载

10 字符串绘制

J2me:

Android:

public native void drawText(String text, float x, float y, Paint paint);

多个重载

11 setClip

J2me:

Android:

public boolean clipRect(float left, float top, float right, float bottom,Region.Op op)

最后一个参数为：Region.Op.REPLACE

12旋转

J2me:

drawRegion()

drawImage()

Android:

还没找到好的方法，不过可以先创建一张翻转后的图片，再使用，封装好的代码如下：

//创建翻转图片

public Bitmap createTransImage(Bitmap img,int trans)

{

// Bitmap img;

try

{

// img = BitmapFactory.decodeResource(getResources(),sImg);

int width = img.getWidth();

int height = img.getHeight();

int newWidth = 200;

int newHeight = 200;

// calculate the scale – in this case = 0.4f

float scaleWidth = ((float) newWidth) / width;

float scaleHeight = ((float) newHeight) / height;

// createa matrix for the manipulation

Matrix matrix = new Matrix();

// resize the bit map

matrix.postScale(scaleWidth, scaleHeight);

// rotate the Bitmap

int degree=0;

Bitmap resizedBitmap=null;

int data[];

int buf;

switch(trans)

{

case ROTATE_HOR:

//创建镜像翻转

data=new int [img.getWidth()*img.getHeight()];

img.getPixels(data, 0, img.getWidth(), 0, 0, img.getWidth(),img.getHeight());

//交换数据

for(int i=0;i

for(int j=0;j

{

buf=data[i*img.getWidth()+j];

data[i*img.getWidth()+j]=data[img.getWidth()*(i+1)-(j+1)];

data[img.getWidth()*(i+1)-(j+1)]=buf;

}

resizedBitmap=Bitmap.createBitmap(data, img.getWidth(),

img.getHeight(), Bitmap.Config.ARGB_4444);;

return resizedBitmap;

case ROTATE_VER:

//创建镜像翻转

data=new int [img.getWidth()*img.getHeight()];

img.getPixels(data, 0, img.getWidth(), 0, 0, img.getWidth(),img.getHeight());

//交换数据

for(int i=0;i

for(int j=0;j

{

buf=data[i*img.getWidth()+j];

data[i*img.getWidth()+j]=data[(img.getHeight()-i-1)*img.getWidth()+j];

data[(img.getHeight()-i-1)*img.getWidth()+j]=buf;

}

resizedBitmap=Bitmap.createBitmap(data, img.getWidth(),

img.getHeight(), Bitmap.Config.ARGB_4444);;

return resizedBitmap;

case ROTATE_90:

matrix.postRotate(90);

// recreate the new Bitmap

resizedBitmap = Bitmap.createBitmap(img, 0, 0,

width, height, matrix, true);

return resizedBitmap;

case ROTATE_180:

matrix.postRotate(180);

// recreate the new Bitmap

resizedBitmap = Bitmap.createBitmap(img, 0, 0,

width, height, matrix, true);

return resizedBitmap;

case ROTATE_270:

matrix.postRotate(270);

// recreate the new Bitmap

resizedBitmap = Bitmap.createBitmap(img, 0, 0,

width, height, matrix, true);

return resizedBitmap;

}

return resizedBitmap;

}

catch (Exception e)

{

return null;

}

}

13 drawRect

J2me:

Android:

public void drawRect(float left, float top, float right, float bottom,Paint paint)

14 声音处理

J2me:

Android:

创建：

MediaPlayer coverSound =MediaPlayer.create(Activity,R.raw.back);

coverSound.prepare();

播放：

coverSound.start();

暂停：

coverSound.pause();

声音设置：

AudioManager vc = (AudioManager)Activity.getSystemService(Context.AUDIO_SERVICE);

vc.adjustVolume(AudioManager.ADJUST_LOWER, 1);

关闭：

coverSound.stop();

coverSound.release();

15 中断处理

J2me:

Android:

public void onWindowFocusChanged(boolean visibility)

16 填充屏幕

J2me:

Android:

CanvasInstance.drawColor(int color)

l7 按键处理

J2me:

Android:

要使按键可以被响应，需要在构造函数中调用

this.setFocusable(true);

处理方法：

public boolean onKeyDown(int keyCode, KeyEvent msg)

public boolean onKeyUp(int keyCode, KeyEvent msg)

18 触摸屏处理

J2me:

Android:

public boolean onTouchEvent(MotionEvent me)

{

if(me.getAction()==MotionEvent.ACTION_DOWN)

。。。。。。

else if(me.getAction()==MotionEvent.ACTION_UP)

。。。。。。

return true;

}

19 资源文件的的存放位置及读取

J2me:

Android:

图片：

Res\drawable：

声音：

Res\raw

数据：

Asserts

InputStream is=ActivityInstance.getAssets().open(path + “.dat”);

20 屏幕刷新，

J2me:

repaint()

Android:

postInvalidate();

21 颜色的使用

J2me:

Android:

PaintInstance.setColor(0xAARRGGBB);

22 数据保存和读取

J2me:

Android:

保存：

SharedPreferences settings = ActivityInstance.getSharedPreferences(String name,int mode);

SharedPreferences.Editor editor = settings.edit();

editor.putBoolean(“hasRec”, true);

。。。。。

editor.putInt(“ex”,enemy[i].i_X_abs);

editor.commit();

读取：

SharedPreferences settings = ActivityInstance.getSharedPreferences (String name,int mode);

this.curFaceDirection=settings.getInt(“cd”, 0);

23 填充方式

J2me:

Android:

paint.setStyle(Style.FILL);

paint.setStyle(Style.STROKE);

24锚点

J2me:

Android:

setTextAlign(Paint.Align.LEFT);

25 连接处理

J2me:

HttpConnection conn = (HttpConnection) Connector.open(“www.baidu.com”, Connector.READ, true);

conn.setRequestMethod(“GET”);

conn.setRequestProperty(“accept”, “**”);

String location = conn.getRequestProperty(“location”);

int resCode = conn.getResponseCode();

InputStream stream = conn.getInputStream();

conn.disconnect();

总结了一下，有以下几点不同之处：

J2ME中的连接从Connector打开，Android中从URL对象打开

要设置连接是否可读写，J2ME中可以直接在Connector.Open时设置，而在Android中必须使用setDoInput(boolean)和setDoOutput(boolean)方法设置

在J2ME中可以在Connector.Open中对连接进行超时设置，在Android中使用setConnectTimeout(int)不仅可以对连接超时进行设置，还能设置超时时间，参数为0时忽略连接超时

在使用这些Api时，一定要注意每个参数的意义，比如j2me中drawRect的后两个参数为宽度和高度，而在Android中则变成了结束点的坐标，使用时千万不能想当然的随意传参。

对于Override方法的定义，一定别忘了super.的方式来进行回调。

上面基本上把J2ME和Android在2D游戏游戏开发中常用的API做了一个比较，了解这些内容后，基本上是可以比较容易地把ME的游戏游戏平顺地迁 移到Android平台。当然，此处只限制为游戏，如果你想把一款J2ME的软件迁移到Android平台，此方法并不适用，你需要学习android的 控件的使用。

出自：http://blog.sina.com.cn/shilverfox

splitImageClips = true – 加载图片切片
          Image[] loadImageClip(String spriteName,int imageId,int x,int y,int w,int h,int orientationUsedInStudio);

-spriteName
         – 动作数据文件的名字
-orientationUsedInStudio
        -使用了的翻转类型,
               MSprite.ORIENTATION_NONE                         – 无翻转
               MSprite.ORIENTATION_FLIP_H                      - 水平翻转
               MSprite.ORIENTATION_FLIP_V                      - 垂直翻转
               MSprite.ORIENTATION_FLIP_BOTH_H_V   – 水平和垂直翻转
- imageId
         – 图片id，即动作所使用到的图片
-x,y,w,h      
       -切片在图片中的坐标（x，y，宽，高）.
Image[3]
       Image[0] =无翻转图片
       Image[1] = 水平翻转图片      // 如果没有为null
       Image[2] = 垂直翻转图片         // 如果没有为null
4、播放动作
/*动作列表*/
public static int ANIM_STAND = 0;
public static int ANIM_RUN = 1;

/* 创建动作播放器 */
MSimpleAnimationPlayer player = new MSimpleAnimationPlayer(MSpriteData spriteData, int spriteX, int spriteY);
或
MSpriteAnimationPlayer player = new MSpriteAnimationPlayer(MSpriteData spriteData, MSprite sprite);
两个的区别在于：正如名字一样MSpriteAnimationPlayer提供的一个简单的播放器，它在处理end of animation时是仅停止播放，不能更好地拓展。如果需要灵巧地控制各个动画的切换最好使用MSpriteAnimationPlayer。

/*设置当前的播放动作*/
player.setAnimation(ANIM_STAND);
player.setLoopOffset(-1);           // 播放一次..
player.setLoopOffset(0);            // 从第一帧到帧尾循环播放
player.setLoopOffset(2);           // 从第二帧到帧尾循环播放

/* 循环调用这里，更新和绘制动作*/
player.update();
player.drawFrame(g);

例子：使用第一节的数据文件，当我们按数字键5或者中键的时候施放这个向下攻击的动作。主要代码如下：
主屏幕   GameScreen.java
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
public class GameScreen extends Canvas implements Runnable {
private GameSprite gameSprite;//游戏精灵
private static final int KEY_FIRE=-5;//键盘中键
public static boolean isHit = false;//是否发动攻击
public GameScreen() {
  gameSprite = new GameSprite();//实例化游戏精灵
  Thread t = new Thread(this);//创建线程
  t.start();//启动线程
}
protected void paint(Graphics g) {
  g.setColor(0xffffffff);
  g.fillRect(0, 0, getWidth(), getHeight());//清屏
  gameSprite.paint(g);//绘制精灵
}
public void run() {
  try {
   long time;
   while (true) {
    time = System.currentTimeMillis();
    //重绘
    repaint();
    serviceRepaints();
    if (isHit) {//如果发动攻击
     gameSprite.update();//更新精灵
    }
    long timeTakenForPainting = System.currentTimeMillis() – time;
    if (timeTakenForPainting < 100) {
     Thread.sleep(100 – timeTakenForPainting);
    }
   }
  } catch (Exception e) {
   System.out.println(“Error ” + e);
  }
}
protected void keyPressed(int key) {
  if (key == Canvas.KEY_NUM5 || key == KEY_FIRE) {
   isHit = true;//按数字键5或中键攻击
  }
}
protected void keyReleased(int key) {
}
}

游戏精灵  GameSprite.java
import javax.microedition.lcdui.Graphics;
import com.studio.motionwelder.MPlayer;
import com.studio.motionwelder.MSprite;
import com.studio.motionwelder.MSpriteAnimationPlayer;
import com.studio.motionwelder.MSpriteData;
import com.studio.motionwelder.MSpriteLoader;
public class GameSprite implements MSprite {
private MSpriteData spriteData;
private MPlayer player;
private int animation;
private static final int DOWN_HIT = 0;
int spriteX = 100;//精灵坐标
int spriteY = 175;
public GameSprite() {
  try {
   loadResource();//加载资源
  } catch (Exception e) {
   e.printStackTrace();
  }
  player = new MSpriteAnimationPlayer(spriteData, this);//创建播放器
  this.setAnimation(DOWN_HIT);//设置当前动画ID
}
private void setAnimation(int animation) {//设置动画ID
  switch (animation) {
  case DOWN_HIT:
   player.setAnimation(DOWN_HIT);
   break;
  }
  this.animation = animation;
}
private void loadResource() throws Exception {
  spriteData = MSpriteLoader.loadMSprite(“/SwordSprite.anu”, true,
    ResourceLoader.getInstance());//加载数据文件
}
public void update() {
  switch (animation) {
  case DOWN_HIT:
   player.setLoopOffset(-1);//设置仅播放一次
   break;
  }
  player.update();//下一帧
}
public void endOfAnimation() {//处理动画播放完后的方法，可以添加切换到另外的动画等等
  switch (animation) {
  case DOWN_HIT:
   player.setFrame(0);//如果播放完则设置帧为第0帧
   break;
  }
  GameScreen.isHit = false;//攻击动作完成
}
public int getSpriteDrawX() {//设置精灵的绘制坐标X
  return spriteX;
}
public int getSpriteDrawY() {//设置精灵的绘制坐标Y
  return spriteY;
}
public byte getSpriteOrientation() {//设置精灵的方向
  return 0;
}
public void updateSpritePosition(int arg0, int arg1) {
  //更新精灵的位置，比如跑动是X及Y的坐标变化
}
public void paint(Graphics g) {
  player.drawFrame(g);//绘制动作的帧
}
}

资源加载 ResourceLoader.java
import java.io.IOException;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;
import com.studio.motionwelder.MSprite;
import com.studio.motionwelder.MSpriteImageLoader;
public class ResourceLoader implements MSpriteImageLoader {
private static ResourceLoader resLoader;// 单例
private ResourceLoader() {
}
public static ResourceLoader getInstance() {// 获取ResourceLoader的实例
  if (resLoader == null)
   resLoader = new ResourceLoader();
  return resLoader;
}
public Image[] loadImage(String spriteName, int imageId,
   int orientationUsedInStudio) {// 整图形式加载图片
  return null;
}
public Image[] loadImageClip(String spriteName, int imageId, int x, int y,
   int w, int h, int orientationUsedInStudio) {// 切片形式加载图片
  boolean doYouNeedHFlippedSpriteInYourgame = false;
  boolean doYouNeedVFlippedSpriteInYourgame = false; // 是否有旋转操作
  Image baseImage = null;
  if (imageId == 0) {
   baseImage = loadImage(“/hero.png”);
   doYouNeedHFlippedSpriteInYourgame = false;
   doYouNeedVFlippedSpriteInYourgame = false;
  }
  Image img[] = new Image[3];
  img[0] = Image.createImage(baseImage, x, y, w, h, Sprite.TRANS_NONE); // 保存无旋转的切片
  /** 如果使用了Nokia的图像操作就不要这样用，关于Nokia的操作作者在库代码里把它注释掉了 */
  if (orientationUsedInStudio == MSprite.ORIENTATION_FLIP_H
    || orientationUsedInStudio == MSprite.ORIENTATION_FLIP_BOTH_H_V
    || doYouNeedHFlippedSpriteInYourgame)
   img[1] = Image.createImage(baseImage, x, y, w, h,
     Sprite.TRANS_MIRROR); // 保存水平旋转的切片
  /** 如果使用了Nokia的图像操作就不要这样用，关于Nokia的操作作者在库代码里把它注释掉了 */
  if (orientationUsedInStudio == MSprite.ORIENTATION_FLIP_V
    || orientationUsedInStudio == MSprite.ORIENTATION_FLIP_BOTH_H_V
    || doYouNeedVFlippedSpriteInYourgame)
   img[2] = Image.createImage(baseImage, x, y, w, h,
     Sprite.TRANS_MIRROR_ROT180); // 保存垂直旋转的切片
  return img;
}
private Image loadImage(String imagePath) {
  try {
   Image img = Image.createImage(imagePath);
   return img;
  } catch (IOException e) {
   e.printStackTrace();
  }
  return null;
}
}

我写了程序本来想在NOkia 6108上比较用和不用的区别，结果这个手机自己就支持双缓冲，所以根本没有比较出来。不过了解这个技术还是有必要的，所以我决定还是写出来。双缓冲本来是在开发PC应用程序的时候遇到的。在MIDP开发中同样存在，当你在屏幕上进行原始写画的时候，如果很复杂的话，用户会发现界面在闪烁。因此你可以这样做，首先在另一个图片上进行paint()得操作，当完成了以后就把它copy到屏幕上，由于通常copy得时候速度很快就不会出现闪烁了。这个技术就是双缓冲。

Canvas类提供了isDoubleBuffered()方法来判断设备是不是支持这个功能，如果返回true的话，那么我们就没有必要使用双缓冲了，如果false的话，我们可以这么做：
public DoubleCanvas(UIController uicontroller)
{
super();
this.uicontroller = uicontroller;
width = this.getWidth();
height = this.getHeight();
this.setCommandListener(this);
if(!isDoubleBuffered())
{
offImage = Image.createImage(width,height);
}

}
protected void paint(Graphics arg0)
{

arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
Graphics saved = arg0;
if(offImage != null)
{
arg0 = offImage.getGraphics();
}
arg0.setColor(255,128,128);
for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
{
arg0.drawRect(i,j,width-2*i,height-2*j);
}
if(arg0 != saved)
{
saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);
}

}

得到offImage得Graphics实例后，进行paint()得操作。这个部分通常比较复杂，我这里的不够复杂：）
然后把offImage直接copy到屏幕上也就是执行saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);

我写了一个应用程序来比较使用和不使用双缓冲的效果，但是由于我的手机支持双缓冲所以看不出效果，如果你有兴趣，那么可以把paint()部分的代码修改的复杂一些然后再移植到不支持的手机上也许可以看出效果，下面是我程序的代码：

import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class DoubleBufferMIDlet extends MIDlet
{
private UIController uicontroller;

protected void startApp() throws MIDletStateChangeException
{
uicontroller = new UIController(this);
uicontroller.init();

}

protected void pauseApp()
{

}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException
{
}

}

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.List;

public class MainListUI extends List implements CommandListener
{
private UIController uicontroller;

public MainListUI(UIController uicontroller)
{
super(“Test”,List.IMPLICIT);
this.uicontroller = uicontroller;
this.append(“Non-buffer”,null);
this.append(“Double-buffer”,null);
this.setCommandListener(this);
}

public void commandAction(Command arg0, Displayable arg1)
{

if(arg0 == List.SELECT_COMMAND)
{
if(this.getSelectedIndex() == 0)
{

uicontroller.handleEvent(UIController.EventID.DISPLAY_NON_BUFFER);
}
else
{

uicontroller.handleEvent(UIController.EventID.DISPLAY_BUFFER);
}
}

}

}

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;

public class UIController implements CommandListener
{

private Display display;
private DoubleBufferMIDlet midlet;
private MainListUI mainList;
private NonDoubleCanvas noDoubleCanvas;
private DoubleCanvas doubleCanvas;
public static final Command backCommand = new Command(“Back”,Command.BACK,2);

public static class EventID
{
public static final int DISPLAY_NON_BUFFER = 0;
public static final int DISPLAY_BUFFER = 1;
}

public UIController(DoubleBufferMIDlet midlet)
{
this.midlet = midlet;
}

public void init()
{
display = Display.getDisplay(midlet);
mainList = new MainListUI(this);
noDoubleCanvas = new NonDoubleCanvas(this);
doubleCanvas = new DoubleCanvas(this);
addCommand();
display.setCurrent(mainList);
}

public void addCommand()
{
noDoubleCanvas.addCommand(backCommand);
doubleCanvas.addCommand(backCommand);
}

public Display getDisplay()
{
return display;
}

public void setCurrent(Displayable disp)
{
display.setCurrent(disp);
}

public void handleEvent(int eventID)
{
switch(eventID)
{
case EventID.DISPLAY_BUFFER:
{
setCurrent(doubleCanvas);
System.out.println(EventID.DISPLAY_BUFFER);
break;
}
case EventID.DISPLAY_NON_BUFFER:
{
setCurrent(noDoubleCanvas);
System.out.println(EventID.DISPLAY_NON_BUFFER);
break;
}
}
}
public void commandAction(Command arg0, Displayable arg1)
{

if(arg0 == backCommand)
{
display.setCurrent(mainList);
}

}

}

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;

public class NonDoubleCanvas extends Canvas implements CommandListener
{

private UIController uicontroller;
private int width;
private int height;

public NonDoubleCanvas(UIController uicontroller)
{
super();
this.uicontroller = uicontroller;
width = this.getWidth();
height = this.getHeight();
this.setCommandListener(this);
}

protected void paint(Graphics arg0)
{

arg0.setColor(100,100,100);
arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
{
arg0.drawRect(i,j,width-2*i,height-2*j);
}

}

public void commandAction(Command arg0, Displayable arg1)
{

uicontroller.commandAction(arg0,arg1);
}

}

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public class DoubleCanvas extends Canvas implements CommandListener
{

private UIController uicontroller;
private Image offImage;
private int width;
private int height;

public DoubleCanvas(UIController uicontroller)
{
super();
this.uicontroller = uicontroller;
width = this.getWidth();
height = this.getHeight();
this.setCommandListener(this);
if(!isDoubleBuffered())
{
offImage = Image.createImage(width,height);
}

}

protected void paint(Graphics arg0)
{

arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
Graphics saved = arg0;
if(offImage != null)
{
arg0 = offImage.getGraphics();
}
arg0.setColor(255,128,128);
for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
{
arg0.drawRect(i,j,width-2*i,height-2*j);
}
if(arg0 != saved)
{
saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);
}

}

public void commandAction(Command arg0, Displayable arg1)
{
uicontroller.commandAction(arg0,arg1);
}

}