如何设置计时器在android?

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

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

很简单! 你创建了一个新的定时器。< / p >

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类(在接受的答案中有示例)。

您希望UI更新发生在已经存在的UI线程中。

最好的方法是使用一个Handler，它使用postDelayed在延迟后运行一个Runnable(每次运行都安排下一次运行);使用removeCallbacks清除回调。

您已经找到了正确的地方，所以再看一遍，也许可以弄清楚为什么代码示例不是您想要的。(另请参阅从Timer更新UI上的同一文章)。

好的，因为这个还没有清除，有3个简单的方法来处理这个。 下面的示例显示了所有3种方法，底部的示例显示了我认为更可取的方法。还记得在onPause中清理你的任务，必要时保存状态

import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Handler.Callback;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;


public class main extends Activity {
TextView text, text2, text3;
long starttime = 0;
//this  posts a message to the main thread from our timertask
//and updates the textfield
final Handler h = new Handler(new Callback() {


@Override
public boolean handleMessage(Message msg) {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;


text.setText(String.format("%d:%02d", minutes, seconds));
return false;
}
});
//runs without timer be reposting self
Handler h2 = new Handler();
Runnable run = new Runnable() {


@Override
public void run() {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;


text3.setText(String.format("%d:%02d", minutes, seconds));


h2.postDelayed(this, 500);
}
};


//tells handler to send a message
class firstTask extends TimerTask {


@Override
public void run() {
h.sendEmptyMessage(0);
}
};


//tells activity to run on ui thread
class secondTask extends TimerTask {


@Override
public void run() {
main.this.runOnUiThread(new Runnable() {


@Override
public void run() {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;


text2.setText(String.format("%d:%02d", minutes, seconds));
}
});
}
};




Timer timer = new Timer();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);


text = (TextView)findViewById(R.id.text);
text2 = (TextView)findViewById(R.id.text2);
text3 = (TextView)findViewById(R.id.text3);


Button b = (Button)findViewById(R.id.button);
b.setText("start");
b.setOnClickListener(new View.OnClickListener() {


@Override
public void onClick(View v) {
Button b = (Button)v;
if(b.getText().equals("stop")){
timer.cancel();
timer.purge();
h2.removeCallbacks(run);
b.setText("start");
}else{
starttime = System.currentTimeMillis();
timer = new Timer();
timer.schedule(new firstTask(), 0,500);
timer.schedule(new secondTask(),  0,500);
h2.postDelayed(run, 0);
b.setText("stop");
}
}
});
}


@Override
public void onPause() {
super.onPause();
timer.cancel();
timer.purge();
h2.removeCallbacks(run);
Button b = (Button)findViewById(R.id.button);
b.setText("start");
}
}

要记住的主要事情是，UI只能从主UI线程修改，所以使用处理程序或活动。

以下是我认为最好的方法。

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;


public class TestActivity extends Activity {


TextView timerTextView;
long startTime = 0;


//runs without a timer by reposting this handler at the end of the runnable
Handler timerHandler = new Handler();
Runnable timerRunnable = new Runnable() {


@Override
public void run() {
long millis = System.currentTimeMillis() - startTime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;


timerTextView.setText(String.format("%d:%02d", minutes, seconds));


timerHandler.postDelayed(this, 500);
}
};


@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.test_activity);


timerTextView = (TextView) findViewById(R.id.timerTextView);


Button b = (Button) findViewById(R.id.button);
b.setText("start");
b.setOnClickListener(new View.OnClickListener() {


@Override
public void onClick(View v) {
Button b = (Button) v;
if (b.getText().equals("stop")) {
timerHandler.removeCallbacks(timerRunnable);
b.setText("start");
} else {
startTime = System.currentTimeMillis();
timerHandler.postDelayed(timerRunnable, 0);
b.setText("stop");
}
}
});
}


@Override
public void onPause() {
super.onPause();
timerHandler.removeCallbacks(timerRunnable);
Button b = (Button)findViewById(R.id.button);
b.setText("start");
}


}

如果你还需要在UI线程(而不是定时器线程)上运行代码，请查看博客:http://steve.odyfamily.com/?p=12

public class myActivity extends Activity {
private Timer myTimer;


/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);


myTimer = new Timer();
myTimer.schedule(new TimerTask() {
@Override
public void run() {
TimerMethod();
}


}, 0, 1000);
}


private void TimerMethod()
{
//This method is called directly by the timer
//and runs in the same thread as the timer.


//We call the method that will work with the UI
//through the runOnUiThread method.
this.runOnUiThread(Timer_Tick);
}




private Runnable Timer_Tick = new Runnable() {
public void run() {


//This method runs in the same thread as the UI.


//Do something to the UI thread here


}
};
}

void method(boolean u,int max)
{
uu=u;
maxi=max;
if (uu==true)
{
CountDownTimer uy = new CountDownTimer(maxi, 1000)
{
public void onFinish()
{
text.setText("Finish");
}


@Override
public void onTick(long l) {
String currentTimeString=DateFormat.getTimeInstance().format(new Date());
text.setText(currentTimeString);
}
}.start();
}


else{text.setText("Stop ");
}

如果有人感兴趣，我开始尝试创建一个标准对象来运行在活动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();
}

他是更简单的解决方案，工作在我的应用程序。

  public class MyActivity extends Acitivity {


TextView myTextView;
boolean someCondition=true;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.my_activity);


myTextView = (TextView) findViewById(R.id.refreshing_field);


//starting our task which update textview every 1000 ms
new RefreshTask().execute();






}


//class which updates our textview every second


class RefreshTask extends AsyncTask {


@Override
protected void onProgressUpdate(Object... values) {
super.onProgressUpdate(values);
String text = String.valueOf(System.currentTimeMillis());
myTextView.setText(text);


}


@Override
protected Object doInBackground(Object... params) {
while(someCondition) {
try {
//sleep for 1s in background...
Thread.sleep(1000);
//and update textview in ui thread
publishProgress();
} catch (InterruptedException e) {
e.printStackTrace();


};
return null;
}
}
}

这里有一个简单可靠的方法…

将以下代码放入Activity中，当Activity处于“恢复”状态时，tick()方法将在UI线程中每秒调用一次。当然，您可以更改tick()方法来做您想做的事情，或者更频繁地调用它。

@Override
public void onPause() {
_handler = null;
super.onPause();
}


private Handler _handler;


@Override
public void onResume() {
super.onResume();
_handler = new Handler();
Runnable r = new Runnable() {
public void run() {
if (_handler == _h0) {
tick();
_handler.postDelayed(this, 1000);
}
}


private final Handler _h0 = _handler;
};
r.run();
}


private void tick() {
System.out.println("Tick " + System.currentTimeMillis());
}

对于那些感兴趣的人来说，“_h0=_handler”代码是必要的，以避免在tick周期内暂停和恢复活动时同时运行两个计时器。

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;


import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.TextView;
import android.app.Activity;


public class MainActivity extends Activity {


CheckBox optSingleShot;
Button btnStart, btnCancel;
TextView textCounter;


Timer timer;
MyTimerTask myTimerTask;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
optSingleShot = (CheckBox)findViewById(R.id.singleshot);
btnStart = (Button)findViewById(R.id.start);
btnCancel = (Button)findViewById(R.id.cancel);
textCounter = (TextView)findViewById(R.id.counter);


btnStart.setOnClickListener(new OnClickListener(){


@Override
public void onClick(View arg0) {


if(timer != null){
timer.cancel();
}


//re-schedule timer here
//otherwise, IllegalStateException of
//"TimerTask is scheduled already"
//will be thrown
timer = new Timer();
myTimerTask = new MyTimerTask();


if(optSingleShot.isChecked()){
//singleshot delay 1000 ms
timer.schedule(myTimerTask, 1000);
}else{
//delay 1000ms, repeat in 5000ms
timer.schedule(myTimerTask, 1000, 5000);
}
}});


btnCancel.setOnClickListener(new OnClickListener(){


@Override
public void onClick(View v) {
if (timer!=null){
timer.cancel();
timer = null;
}
}
});


}


class MyTimerTask extends TimerTask {


@Override
public void run() {
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpleDateFormat =
new SimpleDateFormat("dd:MMMM:yyyy HH:mm:ss a");
final String strDate = simpleDateFormat.format(calendar.getTime());


runOnUiThread(new Runnable(){


@Override
public void run() {
textCounter.setText(strDate);
}});
}


}


}

. xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:orientation="vertical"
tools:context=".MainActivity" >


<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:autoLink="web"
android:text="http://android-er.blogspot.com/"
android:textStyle="bold" />
<CheckBox
android:id="@+id/singleshot"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Single Shot"/>

如果你只是想安排一个倒计时，直到未来的某个时间，并在此过程中定期通知，你可以使用自API级别1起可用的CountDownTimer类。

new CountDownTimer(30000, 1000) {
public void onTick(long millisUntilFinished) {
editText.setText("Seconds remaining: " + millisUntilFinished / 1000);
}


public void onFinish() {
editText.setText("Done");
}
}.start();

你也可以使用动画器:

int secondsToRun = 999;


ValueAnimator timer = ValueAnimator.ofInt(secondsToRun);
timer.setDuration(secondsToRun * 1000).setInterpolator(new LinearInterpolator());
timer.addUpdateListener(new ValueAnimator.AnimatorUpdateListener()
{
@Override
public void onAnimationUpdate(ValueAnimator animation)
{
int elapsedSeconds = (int) animation.getAnimatedValue();
int minutes = elapsedSeconds / 60;
int seconds = elapsedSeconds % 60;


textView.setText(String.format("%d:%02d", minutes, seconds));
}
});
timer.start();

我认为你可以用Rx方法来做:

 timerSubscribe = Observable.interval(1, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
//TODO do your stuff
}
});

然后取消这个:

timerSubscribe.unsubscribe();

Rx定时器http://reactivex.io/documentation/operators/timer.html

这是一个定时器的简单代码:

Timer timer = new Timer();
TimerTask t = new TimerTask() {
@Override
public void run() {


System.out.println("1");
}
};
timer.scheduleAtFixedRate(t,1000,1000);

对于那些不能依赖高度精确的钟表的人，我从其中一个建议中创建了一个实用程序类:

public class TimerTextHelper implements Runnable {
private final Handler handler = new Handler();
private final TextView textView;
private volatile long startTime;
private volatile long elapsedTime;


public TimerTextHelper(TextView textView) {
this.textView = textView;
}


@Override
public void run() {
long millis = System.currentTimeMillis() - startTime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;


textView.setText(String.format("%d:%02d", minutes, seconds));


if (elapsedTime == -1) {
handler.postDelayed(this, 500);
}
}


public void start() {
this.startTime = System.currentTimeMillis();
this.elapsedTime = -1;
handler.post(this);
}


public void stop() {
this.elapsedTime = System.currentTimeMillis() - startTime;
handler.removeCallbacks(this);
}


public long getElapsedTime() {
return elapsedTime;
}
}

要使用..，只需这样做:

 TimerTextHelper timerTextHelper = new TimerTextHelper(textView);
timerTextHelper.start();

...．．

 timerTextHelper.stop();
long elapsedTime = timerTextHelper.getElapsedTime();

如果你已经有了时间。

public class Timer {
private float lastFrameChanged;
private float frameDuration;
private Runnable r;


public Timer(float frameDuration, Runnable r) {
this.frameDuration = frameDuration;
this.lastFrameChanged = 0;
this.r = r;
}


public void update(float dt) {
lastFrameChanged += dt;


if (lastFrameChanged > frameDuration) {
lastFrameChanged = 0;
r.run();
}
}
}

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

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

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

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

1. final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);
   

2. Just schedule you runnable:

   final Future<?> future = SCHEDULER.schedule(Runnable task, long delay,TimeUnit unit);
   

3. You can now use future to cancel the task or check if it is done for example:

   future.isDone();
   

Hope you will find this useful for creating a tasks in Android.

Complete example:

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

我很惊讶，没有答案会提到RxJava2的解决方案。它真的很简单，提供了一个简单的方法来设置计时器在Android。

首先你需要设置Gradle依赖，如果你还没有这样做:

implementation "io.reactivex.rxjava2:rxjava:2.x.y"

(将x和y替换为当前版本号)

因为我们只有一个简单的无重复任务对象，所以我们可以使用Completable对象:

Completable.timer(2, TimeUnit.SECONDS, Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(() -> {
// Timer finished, do something...
});

对于重复任务，你可以用类似的方式使用Observable:

Observable.interval(2, TimeUnit.SECONDS, Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(tick -> {
// called every 2 seconds, do something...
}, throwable -> {
// handle error
});

Schedulers.computation()确保我们的计时器在后台线程上运行，而.observeOn(AndroidSchedulers.mainThread())意味着我们在计时器结束后运行的代码将在主线程上完成。

为了避免不必要的内存泄漏，您应该确保在Activity/Fragment被销毁时取消订阅。

我抽象定时器，并使它成为一个单独的类:

Timer.java

import android.os.Handler;


public class Timer {


IAction action;
Handler timerHandler = new Handler();
int delayMS = 1000;


public Timer(IAction action, int delayMS) {
this.action = action;
this.delayMS = delayMS;
}


public Timer(IAction action) {
this(action, 1000);
}


public Timer() {
this(null);
}


Runnable timerRunnable = new Runnable() {


@Override
public void run() {
if (action != null)
action.Task();
timerHandler.postDelayed(this, delayMS);
}
};


public void start() {
timerHandler.postDelayed(timerRunnable, 0);
}


public void stop() {
timerHandler.removeCallbacks(timerRunnable);
}
}

和从Timer类中提取主动作为

IAction.java

public interface IAction {
void Task();
}

我是这样用的:

MainActivity.java

public class MainActivity extends Activity implements IAction{
...
Timer timerClass;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
timerClass = new Timer(this,1000);
timerClass.start();
...
}
...
int i = 1;
@Override
public void Task() {
runOnUiThread(new Runnable() {


@Override
public void run() {
timer.setText(i + "");
i++;
}
});
}
...
}

我希望这有助于😊👌

我用这种方法:

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();

解决这个问题很简单。

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

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

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

timer.cancel()

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

enter code here
Thread th=new Thread(new Runnable() {
@Override
public void run() {
try { for(int i=0;i<5;i++) {
b1.setText(""+i);
Thread.sleep(5000);
runOnUiThread(new Runnable() {
@Override
public void run() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
pp();
       

}
}
});
}} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
th.start();

这里是解决方案，您需要在代码中添加以下类。您可以直接向XML文件添加视图。

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.util.AttributeSet;
import android.view.View;
import android.widget.TextView;


import java.util.Locale;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;


public class TimerTextView extends TextView {


private static final int DEFAULT_INTERVAL = 1000;


private Timer timer = new Timer();
private long endTime = 0;
private long interval = DEFAULT_INTERVAL;
private boolean isCanceled = false;


public TimerTextView(Context context) {
super(context);
}


public TimerTextView(Context context, AttributeSet attrs) {
super(context, attrs);
}


public TimerTextView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}


@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public TimerTextView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}


@Override protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
stopTimer();
}


@Override protected void onVisibilityChanged(View changedView, int visibility) {
super.onVisibilityChanged(changedView, visibility);
if (VISIBLE == visibility) {
startTimer();
} else {
stopTimer();
}
}


public void setInterval(long interval) {
if (interval >= 0) {
this.interval = interval;
stopTimer();
startTimer();
}
}


public void setEndTime(long endTime) {
if (endTime >= 0) {
this.endTime = endTime;
stopTimer();
startTimer();
}
}


private void startTimer() {
if (endTime == 0) {
return;
}
if (isCanceled) {
timer = new Timer();
isCanceled = false;
}
timer.scheduleAtFixedRate(new TimerTask() {
@Override public void run() {
if (null == getHandler()) {
return;
}
getHandler().post(new Runnable() {
@Override public void run() {
setText(getDurationBreakdown(endTime - System.currentTimeMillis()));
}
});
}
}, 0, interval);
}


private void stopTimer() {
timer.cancel();
isCanceled = true;
}


private String getDurationBreakdown(long diff) {
long millis = diff;
if (millis < 0) {
return "00:00:00";
}
long hours = TimeUnit.MILLISECONDS.toHours(millis);
millis -= TimeUnit.HOURS.toMillis(hours);
long minutes = TimeUnit.MILLISECONDS.toMinutes(millis);
millis -= TimeUnit.MINUTES.toMillis(minutes);
long seconds = TimeUnit.MILLISECONDS.toSeconds(millis);




return String.format(Locale.ENGLISH, "%02d:%02d:%02d", hours, minutes, seconds);
//return "${getWithLeadZero(hours)}:${getWithLeadZero(minutes)}:${getWithLeadZero(seconds)}"
}
}

import kotlin.concurrent.fixedRateTimer


val timer = fixedRateTimer("Tag", false, 1000, 2500) { /* Your code here */ }

Kotlin非常简单