我对 JavaScript 了解不多，但我认为 Timers 可能是您正在寻找的。

Http://developer.android.com/reference/java/util/timer.html

链接如下:

一次性发射被安排在绝对时间或相对延迟之后运行。循环任务按固定的周期或固定的速率进行调度。

根据你实际想要达到的目标，你应该看看 Android 处理程序:

Http://developer.android.com/reference/android/os/handler.html

如果您之前使用 javascript setTimeout ()等来安排将来运行的任务，那么这就是 Android 的方式(postDelayed/sendMessageDelayed)。

请注意，Handlers 和 Timers 都不会让 Android 手机从睡眠模式中醒来。换句话说，即使屏幕关闭/CPU 处于休眠状态，如果您希望安排实际发生的事情，也需要检查 AlarmManager。

这里有一个 setTimeout 等价物，在尝试更新用户界面时非常有用 经过一段时间的耽搁。

正如您可能知道的，更新用户界面只能从 UI 线程完成。 AsyncTask 通过从该线程调用其 onPostExecute 方法为您完成这项工作。

new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}


return null;
}


@Override
protected void onPostExecute(Void result) {
// Update the User Interface
}


}.execute();

如果你不担心唤醒你的手机或者让你的应用起死回生，试试:

// Param is optional, to run task on UI thread.
Handler handler = new Handler(Looper.getMainLooper());
Runnable runnable = new Runnable() {
@Override
public void run() {
// Do the task...
handler.postDelayed(this, milliseconds) // Optional, to repeat the task.
}
};
handler.postDelayed(runnable, milliseconds);


// Stop a repeating task like this.
handler.removeCallbacks(runnable);

一如既往，Android 有很多方法可以做到这一点，但假设你只是想稍后在同一个线程上运行一段代码，我使用以下方法:

new android.os.Handler(Looper.getMainLooper()).postDelayed(
new Runnable() {
public void run() {
Log.i("tag", "This'll run 300 milliseconds later");
}
},
300);

这就相当于

setTimeout(
function() {
console.log("This will run 300 milliseconds later");
},
300);

SetInterval ()

每 n 毫秒重复一次的函数

Javascript

 setInterval(function(){ Console.log("A Kiss every 5 seconds"); }, 5000);

大约相当于 爪哇咖啡

new Timer().scheduleAtFixedRate(new TimerTask(){
@Override
public void run(){
Log.i("tag", "A Kiss every 5 seconds");
}
},0,5000);

SetTimeout ()

仅在 n 毫秒后起作用的函数

Javascript

setTimeout(function(){ Console.log("A Kiss after 5 seconds"); },5000);

大约相当于 爪哇咖啡

new android.os.Handler().postDelayed(
new Runnable() {
public void run() {
Log.i("tag","A Kiss after 5 seconds");
}
}, 5000);

第一个答案肯定是正确的，这也是我在这个 lambda 版本中所依据的，它在语法上要短得多。由于 Runnable 只有1个重写方法“ run ()”，我们可以使用 lambda:

this.m_someBoolFlag = false;
new android.os.Handler().postDelayed(() -> this.m_someBoolFlag = true, 300);

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


class Clock {
private Timer mTimer = new Timer();


private int mSecondsPassed = 0;
private TimerTask mTask = new TimerTask() {
@Override
public void run() {
mSecondsPassed++;
System.out.println("Seconds passed: " + mSecondsPassed);
}
};


private void start() {
mTimer.scheduleAtFixedRate(mTask, 1000, 1000);
}


public static void main(String[] args) {
Clock c = new Clock();
c.start();
}
}

我正在创建一个安卓的 mp3播放器，我想更新当前的时间每一个 500毫米，所以我这样做

SetInterval

private void update() {
new android.os.Handler().postDelayed(new Runnable() {
@Override
public void run() {
long cur = player.getCurrentPosition();
long dur = player.getDuration();
currentTime = millisecondsToTime(cur);
currentTimeView.setText(currentTime);
if (cur < dur) {
updatePlayer();
}


// update seekbar
seekBar.setProgress( (int) Math.round((float)cur / (float)dur * 100f));
}
}, 500);
}

它递归地调用相同的方法

科特林:

你也可以使用 CountDownTimer:

class Timer {
companion object {
@JvmStatic
fun call(ms: Long, f: () -> Unit) {
object : CountDownTimer(ms,ms){
override fun onFinish() { f() }
override fun onTick(millisUntilFinished: Long) {}
}.start()
}
}
}

在你的代码里:

Timer.call(5000) { /*Whatever you want to execute after 5000 ms*/ }

和 Android 一样，有很多方法可以做到这一点，但是假设你只是想在同一个线程上运行一段代码，我使用以下方法:

new Timer().scheduleAtFixedRate(new TimerTask(){
@Override
public void run(){
Log.i("tag", "Hai Codemaker");
}
},0,1000);

此代码将每秒钟记录一次 Hai Codemaker 文本。

万一有人想..

Kotlin 等效于 JavaScript setInterval/setTimeout

重要 : 记住导入 android.os.Handler。不要被 java.util.logging.Handler弄错了

等同于超时

Javascript: setTimeout ()

setTimeout(function(){
// something that can be run.
}, 1500);

Kotlin: runOnTimeout ()

inline fun runOnTimeout(crossinline block: () -> Unit, timeoutMillis: Long) {
Handler(Looper.getMainLooper()).postDelayed({
block()
}, timeoutMillis)
}

呼叫

runOnTimeout({
// something that can be run.
}, 1500)

等效时间间隔

Javascript: setInterval ()

setInterval(function(){
// something that can be run.
}, 1500);

Kotlin: runOnInterval ()

inline fun runOnInterval(crossinline block: () -> Unit, interval: Long) {
val runnable = object : Runnable {
override fun run() {
block()
handler.postDelayed(this, interval)
}
}
handler.post(runnable)
}

呼叫

runOnInterval({
// something that can be run.
}, 1500)

可取消的超时和间隔

如果要使用自定义处理程序以取消可运行文件，则可以使用以下代码。

暂停

inline fun runOnTimeout(crossinline block: () -> Unit, timeoutMillis: Long) {
runOnTimeout(Handler(Looper.getMainLooper()), block, timeoutMillis)
}


inline fun runOnTimeout(handler: Handler, crossinline block: () -> Unit, timeoutMillis: Long): Runnable {
val runnable = Runnable { block() }
handler.postDelayed(runnable, timeoutMillis)
return runnable
}

暂停: 呼叫

runOnTimeout({
// something that can be run.
}, 1500)


// OR


val runnable = runOnTimeout(mHandler, {
// something that can be run.
}, 1500)
// to cancel
mHandler.removeCallbacks(runnable)

间隔

inline fun runOnInterval(crossinline block: () -> Unit, interval: Long) {
runOnInterval(Handler(Looper.getMainLooper()), block, interval)
}


inline fun runOnInterval(handler: Handler, crossinline block: () -> Unit, interval: Long): Runnable {
val runnable = object : Runnable {
override fun run() {
block()
handler.postDelayed(this, interval)
}
}
handler.post(runnable)
return runnable
}

呼叫

runOnInterval({
// something that can be run.
}, 1500)


// OR


val runnable = runOnInterval(mHandler, {
// something that can be run.
}, 1500)
// to cancel
mHandler.removeCallbacks(runnable)