我的想法是遍历100到999，然后除以2到99之间的数，如果有可以给它整除的就不是质数，但是写成代码数值就是不对，求思路

我也很想知道，求大神分享！！！！！

public void getZhiShu(){
                List<Integer> zhishuList = new ArrayList<Integer>();
                for (int i = 100; i < 1000; i++) {
                        int factors = 0;

                        for (int j = 2; j < Math.sqrt(i) + 1; j++) {
                                if (i % j == 0) {
                                        factors++;
                                }
                        }
                        if (factors == 0) {
                                zhishuList.add(i);
                        }
                }
                for (int k = 0; k < zhishuList.size(); k++) {
                        System.out.println(zhishuList.get(k) + "\t");
                }
                System.out.println("总个数为：" + zhishuList.size());
        }


还有一个帖子：http://bbs.itheima.com/thread-175474-1-1.html

老题目了·~~

我开班前在家自学写过一个类似的1-500内质数排序的 发出来给大家参考下  因为是刚看到面向对象的时候写的, 没有用到任何高级功能  写的也不优化   但是可以满足你的需要  只要加一个>100的判定就行了

1. /**
   
2. 需求:1-500以内的质数从大到小排序
   
3. 思想:先整理质数保存到数组B,然后排序
   
4. */
   
5. 
   
6. class  Sorting
   
7. {
   
8.         void print(int[] b)//打印
   
9.         {
   
10.                 System.out.print("{");
    
11.                 for (int t=0;t<b.length-1 ;t++ )
    
12.                 {
    
13.                         System.out.print(b[t]+",");
    
14.                 }
    
15.                 System.out.println(b[b.length-1]+"}");
    
16.         }
    
17.         int[] sort(int[] b)//冒泡排序
    
18.         {
    
19.                 for (int x=0;x<b.length-1 ;x++ )
    
20.                 {       
    
21.                         for (int y=0;y<b.length-1-x && b[y]<b[y+1] ;y++ )
    
22.                         {       
    
23.                                 change(b,y,y+1);
    
24.                         }
    
25.                 }
    
26.                 return b;
    
27.         }
    
28. 
    
29.         void change(int[]r,int a, int b)//置换位置
    
30.         {
    
31.                 int temp;
    
32.                 temp=r[a];
    
33.                 r[a]=r[b];
    
34.                 r[b]=temp;
    
35.         }
    
36. 
    
37.         int[] choose(int[] a)//返回质数数列
    
38.         {
    
39.                 int i=0;//非质数数字的计数值
    
40.                 for (int x=500;x>=1 ;x-- )//遍历1-500,清空数组中的非质数
    
41.                 {
    
42.                         out: for (int y=2;y<=x/2 ;y++ )//模数循环
    
43.                         {
    
44.                                 if (x%y==0)         //如果x能被除2到x/2的任何数整除,则x不是质数,
    
45.                                 {
    
46.                                         a[x-1]=-1;      //将所有不是质数的值赋值为-1
    
47.                                         i++;
    
48.                                         break out;      //如果能被整除一次代表非质数,跳出到下一个数开始循环
    
49.                                 }
    
50.                         }
    
51.                 }
    
52.                 a[0]=-1;// 数字1不是质数,手动赋值
    
53.                 int[] b=new int[500-i-1];//创建质数数组b,总数为500减去非质数的数值再减去1
    
54.                 int index=0;
    
55.                 for (int x=1;x<=500 ;x++ )//将a数组剩余的质数赋值到b
    
56.                 {
    
57.                         if (a[x-1]!=-1)
    
58.                         {
    
59.                                 b[index]=a[x-1];
    
60.                                 index++;
    
61.                         }
    
62.                 }
    
63.                 return b;
    
64.         }
    
65. 
    
66.         int[] add(int[] a)
    
67.         {
    
68.                 for (int x=0;x<a.length ;x++ )//为数组赋值1-500
    
69.                 {
    
70.                         a[x]=x+1;
    
71.                 }
    
72.                 return a;
    
73.         }
    
74. 
    
75.         public static void main(String[] args)
    
76.         {
    
77.                 int[] init=new int[500];
    
78.                 Sorting array =new Sorting();
    
79.                 init = array.add(init);
    
80.                 int[] s = array.choose(init);
    
81.                 init = null;//清空原始数组
    
82.                 array.sort(s);
    
83.                 array.print(s);
    
84.                
    
85.         }
    
86. }
    

复制代码

路过！！！

不错。默默的学习一下

sunsteam 发表于 2015-8-29 00:54
我开班前在家自学写过一个类似的1-500内质数排序的 发出来给大家参考下  因为是刚看到面向对象的时候写的,  ...

写的好复杂啊，看不懂啊

新手路过，大神指导！

这个应该是非常基础的题目啊

1.三位数范围是101到999\

for(int i =101; i<=999;i+=2){}

yanglingui 发表于 2015-8-29 09:28
for(int i =101; i

我感觉是100到999，但是后面用的是for嵌套用if和%来判断是否整除，我的困惑是，嵌套的话会从内循环开始到结束都除一次啊我想要在内循环中找到一个数是可以给它整除的，然后跳出内循环，我的思路是不是错的，求思路

for(int i = 101;i<=999;i+=2){
     for(k=2;k<i;I++){if(i%k!=0){sop(i)}}
}
}

for循环嵌套，再用if来判断是否整除，在计数

yanglingui 发表于 2015-8-29 13:01
for(int i = 101;i

为什么i自加2啊，如果打印放在嵌套循环里，i取一个值，但是有好几个值可以整除他，这样不就会吧那个数打印好几次嘛

1. sum = 0;
   
2.                 int m;
   
3.                 int count = 0;
   
4.                 w : for (i = 2;i < 100 ;i++ ) {
   
5.                         m =(int)Math.sqrt(i);
   
6.                         for (int x = 2;x <= m ;x++ ) {
   
7.                                 if(i % x == 0) {
   
8.                                         continue w ;
   
9.                                 }       
   
10.                                
    
11.                         }
    
12.                         System.out.println(i); //打印1-100之间的素数
    
13.                         count ++;
    
14.                         sum +=i;
    
15.                                        
    
16.                 }
    
17.                 System.out.println("1-100之间的素数有:" + count + "个");
    
18.                 System.out.println("1-100之间的素数和:" + sum);
    
19.         }
    
20. 
    
21. 
    
22. 该下for循环的起点和判断条件~~

复制代码

姜群 发表于 2015-8-29 20:25
为什么i自加2啊，如果打印放在嵌套循环里，i取一个值，但是有好几个值可以整除他，这样不就会吧那个数打 ...

i+2是为了跳过所有的偶数

这个比较复杂，慢慢搞吧