如果有人感兴趣，我开始尝试创建一个标准对象来运行在活动UI线程上。好像还行。欢迎评论。我想这是可用的布局设计器作为一个组件拖到一个活动。真不敢相信这样的东西竟然不存在。

package com.example.util.timer;

import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;

public class ActivityTimer {

    private Activity m_Activity;
    private boolean m_Enabled;
    private Timer m_Timer;
    private long m_Delay;
    private long m_Period;
    private ActivityTimerListener m_Listener;
    private ActivityTimer _self;
    private boolean m_FireOnce;

    public ActivityTimer() {
        m_Delay = 0;
        m_Period = 100;
        m_Listener = null;
        m_FireOnce = false;
        _self = this;
    }

    public boolean isEnabled() {
        return m_Enabled;
    }

    public void setEnabled(boolean enabled) {
        if (m_Enabled == enabled)
            return;

        // Disable any existing timer before we enable a new one
        Disable();

        if (enabled) {
            Enable();
        }
    }

    private void Enable() {
        if (m_Enabled)
            return;

        m_Enabled = true;

        m_Timer = new Timer();
        if (m_FireOnce) {
            m_Timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    OnTick();
                }
            }, m_Delay);
        } else {
            m_Timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    OnTick();
                }
            }, m_Delay, m_Period);
        }
    }

    private void Disable() {
        if (!m_Enabled)
            return;

        m_Enabled = false;

        if (m_Timer == null)
            return;

        m_Timer.cancel();
        m_Timer.purge();
        m_Timer = null;
    }

    private void OnTick() {
        if (m_Activity != null && m_Listener != null) {
            m_Activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    m_Listener.OnTimerTick(m_Activity, _self);
                }
            });
        }
        if (m_FireOnce)
            Disable();
    }

    public long getDelay() {
        return m_Delay;
    }

    public void setDelay(long delay) {
        m_Delay = delay;
    }

    public long getPeriod() {
        return m_Period;
    }

    public void setPeriod(long period) {
        if (m_Period == period)
            return;
        m_Period = period;
    }

    public Activity getActivity() {
        return m_Activity;
    }

    public void setActivity(Activity activity) {
        if (m_Activity == activity)
            return;
        m_Activity = activity;
    }

    public ActivityTimerListener getActionListener() {
        return m_Listener;
    }

    public void setActionListener(ActivityTimerListener listener) {
        m_Listener = listener;
    }

    public void start() {
        if (m_Enabled)
            return;
        Enable();
    }

    public boolean isFireOnlyOnce() {
        return m_FireOnce;
    }

    public void setFireOnlyOnce(boolean fireOnce) {
        m_FireOnce = fireOnce;
    }
}

在活动中，我有这样的onStart:

@Override
protected void onStart() {
    super.onStart();

    m_Timer = new ActivityTimer();
    m_Timer.setFireOnlyOnce(true);
    m_Timer.setActivity(this);
    m_Timer.setActionListener(this);
    m_Timer.setDelay(3000);
    m_Timer.start();
}

您需要创建一个线程来处理更新循环，并使用它来更新文本区域。棘手的部分是只有主线程可以修改ui，所以更新循环线程需要通知主线程进行更新。这是使用处理程序完成的。

查看这个链接:http://developer.android.com/guide/topics/ui/dialogs.html# 点击标题为“Example ProgressDialog with a second thread”的部分。这是一个你需要做什么的例子，除了一个进度对话框而不是一个文本框。

对于想要在kotlin中这样做的人:

val timer = fixedRateTimer(period = 1000L) {
            val currentTime: Date = Calendar.getInstance().time
            runOnUiThread {
                tvFOO.text = currentTime.toString()
            }
        }

为了停止计时器，你可以使用这个:

timer.cancel()

这个函数有许多其他选项，请尝试一下

这很简单! 你创建了一个新的定时器。

Timer timer = new Timer();

然后扩展计时器任务

class UpdateBallTask extends TimerTask {
   Ball myBall;

   public void run() {
       //calculate the new position of myBall
   }
}

然后以一定的更新间隔将新任务添加到Timer中

final int FPS = 40;
TimerTask updateBall = new UpdateBallTask();
timer.scheduleAtFixedRate(updateBall, 0, 1000/FPS);

声明:这不是理想的解决方案。这是使用定时器类的解决方案(由OP要求)。在Android SDK中，建议使用Handler类(在接受的答案中有示例)。

因为这个问题仍然从谷歌搜索吸引了很多用户(关于Android定时器)，我想插入我的两个硬币。

首先，Timer类在Java 9中将被弃用(请阅读已接受的答案)。

官方建议的方法是使用ScheduledThreadPoolExecutor，它更有效，功能丰富，可以额外安排命令在给定延迟后运行，或定期执行。此外，它还提供了ThreadPoolExecutor的额外灵活性和功能。

下面是一个使用普通功能的示例。

创建执行器服务: final ScheduledExecutorService SCHEDULER = executors . newscheduleledthreadpool (1); 只需安排你的runnable: 最后未来< ?> future = SCHEDULER。schedule(可运行任务，长延迟，TimeUnit单元); 你现在可以使用future来取消任务或检查任务是否完成，例如: future.isDone ();

希望你会发现这对在Android中创建任务有用。

完整的例子:

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
Future<?> sampleFutureTimer = scheduler.schedule(new Runnable(), 120, TimeUnit.SECONDS);
if (sampleFutureTimer.isDone()){
    // Do something which will save world.
}

我用这种方法:

String[] array={
       "man","for","think"
}; int j;

然后在onCreate下面

TextView t = findViewById(R.id.textView);

    new CountDownTimer(5000,1000) {

        @Override
        public void onTick(long millisUntilFinished) {}

        @Override
        public void onFinish() {
            t.setText("I "+array[j] +" You");
            j++;
            if(j== array.length-1) j=0;
            start();
        }
    }.start();

解决这个问题很简单。