需求：从1循环到50并在每行打印一个值，并且要在3的倍数上加“foo”,5的倍数上加“biz”,7的倍数上加“baz”.如

class Demo1 {
        public static void main(String[] args) {
               
                for(int x=1;x<=50;x++){
                        if(x%3==0){
                                System.out.println("foo"+x);
                                continue;
                        }else if(x%5==0){
                                System.out.println("biz"+x);
                                continue;
                        }else if(x%7==0){
                                System.out.println("baz"+x);
                                continue;
                        }else{
                                System.out.println(x);
                        }
                       
                }
        }
}
在这个里面一定要注意if 语句的用法，其后的小括号内是一个布尔类型的判断语句，当判断条件为真的话，才会运行方法块内的代码，但是你这个题目要求是一个循环判断，因而要使用continue，让程序继续往下走，看看对你有没有帮助

周亮 发表于 2012-12-24 12:56
class Demo1 {
        public static void main(String[] args) {
               

那既是3的倍数又是5的倍数的情况呢

你是说像15，30之类的数字吗？那里面都包括了啊，你又没规定能同时被整除的前边加什么，我就把他放到第一个条件上了

public class Demo {

        public static void main(String[] args) {

                for(int i = 1; i <= 50; i++){
                        if(i % 3 == 0){
                                System.out.println(x+" foo");
                        }
                       
                        if(i % 5 == 0){
                                System.out.println(x+" biz");
                        }
                        if(i % 7 == 0){
                                System.out.println(x+" baz");
                        }
                        System.out.println(x);

                        
                        

                }
        }
}
让数据多次判断就可以了。

刘经鹏 发表于 2012-12-24 13:34
public class Demo {

        public static void main(String[] args) {

这也是我的思路，恩分就让给你了

1. package org.niit.test;
   
2. 
   
3. import org.junit.Test;
   
4. 
   
5. public class Test3 {
   
6.         /**
   
7.          * 从1循环到50并在每行打印一个值， 并且要在3的倍数上加“foo”,5的倍数上加“biz”,7的倍数上加“baz”.如
   
8.          */
   
9.         @Test
   
10.         public void test1() {
    
11.                 int i = 1;
    
12.                 while (i < 50) {
    
13.                         String str = "";
    
14.                         if (i % 3 == 0) {
    
15.                                 str += "foo";
    
16.                         }
    
17.                         if (i % 5 == 0) {
    
18.                                 str += " biz";
    
19.                         }
    
20.                         if (i % 7 == 0) {
    
21.                                 str += " baz";
    
22.                         }
    
23.                         System.out.println(i + "\t" + str);
    
24.                         i++;
    
25.                 }
    
26.         }
    
27. }
    

复制代码

1. 1       
   
2. 2       
   
3. 3        foo
   
4. 4       
   
5. 5         biz
   
6. 6        foo
   
7. 7         baz
   
8. 8       
   
9. 9        foo
   
10. 10         biz
    
11. 11       
    
12. 12        foo
    
13. 13       
    
14. 14         baz
    
15. 15        foo biz
    
16. 16       
    
17. 17       
    
18. 18        foo
    
19. 19       
    
20. 20         biz
    
21. 21        foo baz
    
22. 22       
    
23. 23       
    
24. 24        foo
    
25. 25         biz
    
26. 26       
    
27. 27        foo
    
28. 28         baz
    
29. 29       
    
30. 30        foo biz
    
31. 31       
    
32. 32       
    
33. 33        foo
    
34. 34       
    
35. 35         biz baz
    
36. 36        foo
    
37. 37       
    
38. 38       
    
39. 39        foo
    
40. 40         biz
    
41. 41       
    
42. 42        foo baz
    
43. 43       
    
44. 44       
    
45. 45        foo biz
    
46. 46       
    
47. 47       
    
48. 48        foo
    
49. 49         baz

复制代码

while少了一个等号
那既是3的倍数又是5的倍数的情况呢
往后面叠加