Question

public void onClick(View v) {
        // TODO Auto-generated method stub
        switch(v.getId()){
        case R.id.rollDice:
            Random ranNum = new Random();
            int number = ranNum.nextInt(6) + 1;
            diceNum.setText(""+number);
            sum = sum + number;
            for(i=0;i<8;i++){
                for(j=0;j<8;j++){

                    int value =(Integer)buttons[i][j].getTag();
                    if(value==sum){
                        inew=i;
                        jnew=j;

                        buttons[inew][jnew].setBackgroundColor(Color.BLACK);
                                                //I want to insert a delay here
                        buttons[inew][jnew].setBackgroundColor(Color.WHITE);
                         break;                     
                    }
                }
            }


            break;

        }
    }

我想在更改背景之间设置命令之间的延迟。我尝试使用线程计时器并尝试使用run和catch。但它没有用。我试过这个

 Thread timer = new Thread() {
            public void run(){
                try {
                                buttons[inew][jnew].setBackgroundColor(Color.BLACK);
                    sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

             }
           };
    timer.start();
   buttons[inew][jnew].setBackgroundColor(Color.WHITE);

但它只是变为黑色。

Answer 1

试试这段代码：

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 5s = 5000ms
        buttons[inew][jnew].setBackgroundColor(Color.BLACK);
    }
}, 5000);

Answer 2

您可以使用CountDownTimer，这比发布的任何其他解决方案更有效。您还可以使用其onTick(long)方法

在整个过程中定期发出通知

看看这个显示30秒倒计时的例子

   new CountDownTimer(30000, 1000) {
         public void onFinish() {
             // When timer is finished 
             // Execute your code here
     }

     public void onTick(long millisUntilFinished) {
              // millisUntilFinished    The amount of time until finished.
     }
   }.start();

Answer 3

如果您在应用中经常使用延迟，请使用此实用程序类

import android.os.Handler;


public class Utils {

    // Delay mechanism

    public interface DelayCallback{
        void afterDelay();
    }

    public static void delay(int secs, final DelayCallback delayCallback){
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                delayCallback.afterDelay();
            }
        }, secs * 1000); // afterDelay will be executed after (secs*1000) milliseconds.
    }
}

用法：

// Call this method directly from java file

int secs = 2; // Delay in seconds

Utils.delay(secs, new Utils.DelayCallback() {
    @Override
    public void afterDelay() {
        // Do something after delay

    }
});

Answer 4

使用Thread.sleep(millis）方法。

Answer 5

如果你想在常规时间间隔内在UI中做一些事情，那么很好的选择就是使用CountDownTimer：

new CountDownTimer(30000, 1000) {

     public void onTick(long millisUntilFinished) {
         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
     }

     public void onFinish() {
         mTextField.setText("done!");
     }
  }.start();

Answer 6

您可以使用此：

import java.util.Timer;

，并为延迟本身添加：

 new Timer().schedule(
                    new TimerTask(){

                        @Override
                        public void run(){

                        //if you need some code to run when the delay expires
                        }

                    }, delay);

“延迟”变量代表毫秒，例如将延迟设置为5000-延迟5秒

Answer 7

用Kotlin处理程序的答案：

1-在文件（例如，包含所有顶级功能的文件）中创建top-level function：

fun delayFunction(function: ()-> Unit, delay: Long) {
    Handler().postDelayed(function, delay)
}

2-然后在需要的地方调用它：

delayFunction({ myDelayedFunction() }, 300)

Answer 8

在此示例中，我将背景图像从两个图像转换为另一个图像，同时具有2秒的alpha淡入延迟-将原始图像的2s淡入转换为2s的淡入第二幅图像。

    public void fadeImageFunction(View view) {

    backgroundImage = (ImageView) findViewById(R.id.imageViewBackground);
    backgroundImage.animate().alpha(0f).setDuration(2000);

    // A new thread with a 2-second delay before changing the background image
    new Timer().schedule(
            new TimerTask(){
                @Override
                public void run(){
                    // you cannot touch the UI from another thread. This thread now calls a function on the main thread
                    changeBackgroundImage();
                }
            }, 2000);
   }

// this function runs on the main ui thread
private void changeBackgroundImage(){
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            backgroundImage = (ImageView) findViewById(R.id.imageViewBackground);
            backgroundImage.setImageResource(R.drawable.supes);
            backgroundImage.animate().alpha(1f).setDuration(2000);
        }
    });
}

Answer 9

我认为，截至2020年，最简单，最稳定和最有用的方法是使用Coroutines的delay函数而不是Runnable。协程是处理异步作业的一个好概念，它的delay组件将是此答案的重点。

警告：协同程序需要科特林语言，我没有将代码转换为科特林，但我认为每个人都可以理解主要概念。

只需将协程添加到您的build.gradle：

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'

将一个作业添加到您的班级（活动，片段等）中，您将在其中使用协程：

private var job: Job = Job()
override val coroutineContext: CoroutineContext
    get() = Dispatchers.Main + job

并且您可以通过启动{} 正文在课堂上任何地方使用协程。因此，您可以这样编写代码：

public void onClick(View v) {

    launch {

        switch(v.getId()) {
            case R . id . rollDice :
            Random ranNum = new Random();
            int number = ranNum . nextInt (6) + 1;
            diceNum.setText("" + number);
            sum = sum + number;
            for (i= 0;i < 8;i++){
                for (j= 0;j < 8;j++){
                    int value =(Integer) buttons [i][j].getTag();
                    if (value == sum) {
                        inew = i;
                        jnew = j;

                        buttons[inew][jnew].setBackgroundColor(Color.BLACK);
                        delay(2000)
                        buttons[inew][jnew].setBackgroundColor(Color.WHITE);
                        break;
                    }
                }
        }
            break;

        }
    }
}

全部...

别忘了launch{}函数是异步，并且 for循环不会等待delay函数完成，例如这个：

launch{
    buttons[inew][jnew].setBackgroundColor(Color.BLACK);
    delay(2000)
    buttons[inew][jnew].setBackgroundColor(Color.WHITE);
}

因此，如果您希望所有的for循环都等待launch{ }，delay应该涵盖for循环。

launch{ }的另一个好处是，您可以使for循环异步，这意味着它不会在繁重的进程中阻塞应用程序的主UI线程。

如何在android中设置延迟？

9 个答案: