标签: do-while

在计数方面,应该使用do-while循环还是for循环？因为这:

class Main {
  public static void main(String[] args) {
    int times = 1;
    do {
      System.out.println("I have printed " + times + " times.");
      times++;
    } while (times < 6);
  }
}

似乎与此完全相同:

class Main {
  public static void main(String[] args) {
    for (int times = 1; times < 6; times++) {
      System.out.println("I have printed " + times + " times.");
    }
  }
}

这是速度的差异吗？偏爱？情况？个人怪癖？某种"Java社会禁忌"？我不知道.似乎可以用于有效计数,只需要更多.两者都打印完全相同的东西.

System.out.println("Many thanks!!");

运行此代码时,我可以期待什么行为:

do while(testA) {

    // do stuff

} while(testB);

它会表现得像:

do {
    while(testA) {
        // do stuff
    }    
} while(testB);

要么:

if(testA) {
    do {
        // do stuff
    } while(testA && testB);
}

还是完全出乎意料的？

我问这个问题是因为我觉得这个问题很模糊,对于其他人来说这个话题,并不是因为我懒得去测试它.

可能重复:
什么时候适当？

有人会介意告诉我这两个陈述之间的区别是什么,何时应该使用另一个陈述？

var counterOne = -1;

do {
    counterOne++;
    document.write(counterOne);
} while(counterOne < 10);

                                                                                 和

var counterTwo = -1;

while(counterTwo < 10) {
    counterTwo++;
    document.write(counterTwo);
}

                                                          http://fiddle.jshell.net/Shaz/g6JS4/

在这个时刻,我没有看到do声明的重点,如果它可以在声明中没有指定它的情况下完成while.

而与之相比

当块为空时,while和do-while在功能上是等效的,尽管看起来更自然:

do {} while (keepLooping());
while (keepLooping()) {}

使用空块的while/do-while的一个典型用例是使用compareAndSet(CAS)强制更新原子对象.例如,下面的代码将以a线程安全的方式递增:

int i;
AtomicInteger a = new AtomicInteger();
while (!a.compareAndSet(i = a.get(), i + 1)) {}

上下文

java.util.concurrent的几个部分使用do {} while (...)CAS操作的惯用语和ForkJoinPool解释的javadoc :

有几种异常do {} while (!cas...)现象是强制更新CAS变量的最简单方法.

既然他们承认这是不寻常的,我认为他们意味着最好而不是最简单.

题

是否存在do {} while (!cas)比while (!cas) {}什么原因更有效的情况？

我正在学习JAVA并键入以下DO ... WHILE示例.如果输入'q',程序将退出.它运行,但为什么我得到三行"请一键,然后按ENTER:"？

class DWDemo {
    public static void main (String args[])
      throws java.io.IOException {
          char ch;
          do {
              System.out.println("Please a key followed by ENTER:");
              ch = (char) System.in.read();
          } while (ch != 'q');
      }
}

我一直在编写一个程序,它将获取一系列音乐文件的名称并播放它们.我成功地做到了这一点,但是,我想要修改一些东西,让它更好一些.我试图让音乐以随机顺序播放,但在整个列表播放之前不重复播放任何歌曲.我几乎能够做到,但我认为我的do-while循环有问题.该程序按预期运行大约八首歌曲,但随后它停止播放音乐,JVM继续运行.我正在使用BlueJ,因为我仍然是AP Comp Sci学生,所以我意识到我可能无法完成这项任务,但任何帮助将不胜感激.我有一个驱动程序,"MusicDriver",它与另外两个类别"有一个"关系:"MP3"和"音乐".

我的MP3课程:

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import javazoom.jl.player.Player;

public class MP3 {
    String filename;
    Player player; 

    public void stopMP3() { if (player != null) player.close(); }

    // play the MP3 file to the sound card
    public void playMP3(String filename) {
    try {
        FileInputStream fis = new FileInputStream(filename);
        BufferedInputStream bis = new BufferedInputStream(fis);
        player = new Player(bis);
    }
    catch (Exception e) {
        System.out.println("Problem playing file " + filename);
        System.out.println(e);
    }

    // run in new thread to play in background …

while循环

测试条件,如果是,则执行代码

do..while循环

第一次执行.然后测试并执行.

所以之间的差异while,并do..while进行,程序在同时,一个试验进行比同时做多

那是

如果一个循环从1到50在while一个语句的循环中执行,它将有51个测试(50个真和1个假),语句将执行50次.

同样

如果一个循环从1到50在do..while循环中执行一个语句,它将有50个测试(第一个测试将不会执行),语句将执行50次.

所以,只有一个测试/检查少.而已.

但是当我测试执行所花费的时间时,它显示出很大的差异.

function whileFn() {
  var i = 0;
  while (i < 10) {
    document.write(i);
    i++;
  }
}

function doWhileFn() {
  var i = 0;
  do {
    document.write(i);
    i++;
  } while (i < 10)
}

console.time('whileFn');
whileFn();
console.timeEnd('whileFn');

document.write('<br/>');

console.time('doWhileFn');
doWhileFn();
console.timeEnd('doWhileFn');

正如您在图像和代码示例中看到的那样,while循环花费do while了15毫秒,而只花了5毫秒.

这种巨大差异背后的原因是什么？

测试10个元素

按照@pid的建议更新

测试1000

需要23mS进行1次额外测试

测试10000

一次额外测试多397.91 mS

进行测试

Chrome(58.0.3029.110) …

虽然本论坛和所有其他论坛多次讨论过这个话题,但我仍有疑问.请帮忙.

do{} while(0)in-macro 如何在Linux内核中工作？例如,

#define preempt_disable()    do { } while (0)

它如何禁用抢占？

#define might_resched()    do { } while (0)

它是如何重新安排的？

类似地,我已经看到了互斥锁和其他宏的宏.这有什么用？我理解以下问题,但不是上面的例子.

#define foo(x)    do { do something } while(0)

编辑:

以下代码怎么样rt_mutex_lock？

/**
 * rt_mutex_lock - lock a rt_mutex
 *
 * @lock: the rt_mutex to be locked
 */
void __sched rt_mutex_lock(struct rt_mutex *lock)
{
        might_sleep();
        rt_mutex_fastlock(lock, TASK_UNINTERRUPTIBLE, 0, rt_mutex_slowlock);
}
EXPORT_SYMBOL_GPL(rt_mutex_lock);


/*
 * debug aware fast / slowpath lock,trylock,unlock
 *
 * The atomic acquire/release ops are compiled away, …

我想知道而不是使用do-while循环,c中等效的for-loop或任何其他循环组合是什么？

我目前正在处理某人的其他代码,并有这样的声明

if(x.start()) do if(y.foo(x)) {

// Do things

}while(x.inc())

这里x是自定义类,它包含信息y并允许以特殊顺序迭代其元素.如果相关,我会提供此信息,但我的问题更为笼统:

我认为在一个 do{}while()声明中该do部分必须跟随括号,并且这个最后while()条件的togheter 定义了do-while循环.

• 为什么我们可以放好if后do呢？
• 它有什么作用？
• 还有什么可以放在之间do和{？

我找不到与此相关或谷歌相关的其他问题,大多数内容与将if语句放入内容有关while loop.