代码之家  ›  专栏  ›  技术社区  ›  Kevin Bradshaw

如何使用android定时器

  •  1
  • Kevin Bradshaw  · 技术社区  · 14 年前

    我什么也没得到 here .

    1 回复  |  直到 5 年前
        1
  •  481
  •   Dave.B    11 年前

    好吧,因为这个问题还没有解决,有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线程进行修改,因此请使用处理程序或活动.runouithread(可运行r);

    这是我认为最好的方法。

    
    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");
        }
    
    }
    
    
    
        2
  •  86
  •   Kiril Kirilov    11 年前

    很简单!

    Timer timer = new Timer();
    

    然后扩展计时器任务

    class UpdateBallTask extends TimerTask {
       Ball myBall;
    
       public void run() {
           //calculate the new position of myBall
       }
    }
    

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

    免责声明:这不是理想的解决方案。这是使用Timer类的解决方案(如OP所要求的)。在androidsdk中,建议使用Handler类(在接受的答案中有示例)。

        3
  •  70
  •   Meir Gerenstadt    12 年前

    如果您还需要在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
    
        }
    };
    }
    
        4
  •  45
  •   Ahmed Hegazy    6 年前

    如果您只想安排一个倒计时直到将来某个时间,并在一路上定期通知,那么您可以使用 CountDownTimer 自API级别1起可用的类。

    new CountDownTimer(30000, 1000) {
        public void onTick(long millisUntilFinished) {
            editText.setText("Seconds remaining: " + millisUntilFinished / 1000);
        }
    
        public void onFinish() {
            editText.setText("Done");
        }
    }.start();
    
        5
  •  28
  •   Pochmurnik SK Developers    6 年前

    下面是一些简单的计时器代码:

    Timer timer = new Timer();
    TimerTask t = new TimerTask() {       
        @Override
        public void run() {
    
            System.out.println("1");
        }
    };
    timer.scheduleAtFixedRate(t,1000,1000);
    
        6
  •  13
  •   Will    9 年前

    我想你可以这样做:

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

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

        7
  •  11
  •   Community CDub    8 年前

    因为这个问题仍然吸引了很多来自google搜索的用户(关于Android timer),我想插入我的两个硬币。

    Timer 类将在Java9中被弃用 (read the accepted answer) .

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

    1. 创建执行器服务:

      final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);
      
    2. final Future<?> future = SCHEDULER.schedule(Runnable task, long delay,TimeUnit unit);
      
    3. 您现在可以使用 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.
    }
    
        8
  •  8
  •   Micer Laraconda    5 年前

    我很惊讶,没有一个答案会提到解决方案 RxJava2 . 它非常简单,并且提供了一种在Android中设置计时器的简单方法。

    首先,您需要设置Gradle依赖项,如果您还没有这样做:

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

    x y 具有 current version number )

    非重复任务 ,我们可以使用 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()) 意味着我们在计时器完成后运行的代码将在主线程上完成。

    为了避免不必要的内存泄漏,您应该确保在活动/片段被销毁时取消订阅。

        9
  •  4
  •   Amir    5 年前

    谁想在科特林这样做:

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

    要停止计时器,可以使用以下命令:

    timer.cancel()
    

    这个函数还有很多其他的选项,试试看吧

        10
  •  2
  •   Risinek    8 年前

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

    最好的方法是使用一个处理程序,该处理程序使用postDelayed在延迟后运行Runnable(每次运行都安排下一次);使用removeCallbacks清除回调。

    您已经找到了正确的位置,所以请再看一遍,也许可以澄清为什么代码示例不是您想要的。(另见同一条第 Updating the UI from a Timer ).

        11
  •  1
  •   Rodion Altshuler    12 年前

    他是更简单的解决方案,在我的应用程序中运行良好。

      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;
                }
            }
        }
    
        12
  •  1
  •   Adam Gawne-Cain    11 年前

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

    将以下代码放入活动中,当活动处于“恢复”状态时,UI线程中的tick()方法将每秒调用一次。当然,您可以更改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());
    }
    

    对于那些感兴趣的人来说,“\u h0=\u handler”代码是必要的,以避免在活动暂停并在计时周期内恢复时两个计时器同时运行。

        13
  •  1
  •   TpoM6oH    9 年前

    也可以使用动画制作工具:

    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();
    
        14
  •  1
  •   Jon    5 年前

    对于那些不能依靠 Chronometer ,我根据其中一个建议做了一个实用类:

    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();
    
        15
  •  0
  •   Nick    14 年前

    您需要创建一个线程来处理update循环,并使用它来更新textarea。不过,棘手的部分是,只有主线程才能真正修改ui,因此更新循环线程需要向主线程发出信号来执行更新。这是使用处理程序完成的。

    http://developer.android.com/guide/topics/ui/dialogs.html# 单击标题为“示例ProgressDialog with a second thread”的部分。这是一个确切的例子,你需要做什么,除了一个进度对话框,而不是一个文本字段。

        16
  •  0
  •   WEFX venkateswararao    12 年前
    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 ");
    }
    
        17
  •  0
  •   James Barwick    12 年前

    如果有人感兴趣的话,我开始尝试创建一个标准对象来运行在activities 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;
        }
    }
    

    在活动中,我有一个开始:

    @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();
    }
    
        18
  •  0
  •   Zar E Ahmer    11 年前
    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"/>
    

        19
  •  0
  •   Matthew Beck    8 年前

    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();
            }
        }
    }
    
        20
  •  0
  •   Yashar Aliabbasi    5 年前

    我把计时器抽象出来,把它变成一个单独的类:

    计时器.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();
    }
    

    我就是这样用的:

    主活动.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++;
            }
        });
    }
    ...
    }
    

    我希望这有帮助

        21
  •  0
  •   Mori    5 年前

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

    这是解决这个问题的简单方法。

        22
  •  0
  •   amra ram    4 年前
    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();