请问质数怎么实现呀，求指教

public static void main(String[] args) {
                //打印指数的范围  从100-999  表示三位数
                print(2,100);
        }
        
        private static void print(int a,int b){
               
                for (int i = a; i < b+1; i++) {
                        int num = dd(i);
                        //队返回来的num进行判断  
                        if(num == i-2){
                                System.out.println(i);
                        }
                }

        }
        
        public static int dd(int c){
                //定义一个计数器num
                int num = 0;
                for (int i = 2; i <c ; i++) {
                        if(c%i != 0){
                                //把传进来的数字c进行从2到c-1的取模运算  当取模运算结果不是0时 把num 加1
                                num++;
                        }
                }
                return num;
        }

1. 
   
2. /*
   
3. * (1)偶数都不是质数，不用判断
   
4. * (2)定义一个判断质数的方法
   
5. * (3)判断2到100之间的质数
   
6. */
   
7. public class Test5 {
   
8.         public static void main(String[] args) {
   
9.                 checkPrime(2,100);//将需要判断的范围传给chickPrime，包含头，不含尾        
   
10.         }
    
11.         
    
12.         public static void checkPrime(int min,int max) { //判断一个范围之间的质数，并打印。
    
13.    
    
14.                 if(min%2==0)//确保从范围内的第一个奇数开始判断
    
15.                         min++;
    
16.                 for(int i=min;i<max;i=i+2 ){ //判断min和max之间的奇数     
    
17.                         if(isPrime(i)) //调用isPrime判断是否为质数,是则输出
    
18.                                 System.out.println(i);            
    
19.                 }
    
20.         }
    
21.         private static boolean isPrime(int max){       //判断一个数是否是质数
    
22.                 for(int i=2;i<max;i++){       //循环起始为除数的范围，即（1，max）的开区间  
    
23.                         if(max%i==0) {     //不能被2至max-1所有数整除，则为质数
    
24.                                 return false;
    
25.                         }
    
26.                         else if(i==max-1)  {
    
27.                                 return true;
    
28.                         }
    
29.                 }
    
30.                 return false;
    
31.        }
    
32. }
    

复制代码

楼上两位都是正解

感觉第一个好懂一点

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. /**
   
4. * 判断一个数是否为素数：
   
5. *
   
6. * 质数：
   
7. * 质数又称素数。指在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数。
   
8. * 只有两个正因数（1和自己）的自然数即为素数。比1大但不是素数的数称为合数。
   
9. * 1和0既非素数也非合数。合数是由若干个质数相乘而得到的。所以，质数是合数的基础，没有质数就没有合搜索数。
   
10. *
    
11. *
    
12. * @author melox
    
13. *
    
14. */
    
15. public class Integer {
    
16.         public static void main(String[] args) {
    
17.                 primesShow(getPrimes(2,100));
    
18.                
    
19.         }
    
20.        
    
21.         /*这里用java.lang.Integer主要是因为我的类名和java自带的有冲突*/       
    
22.         public static List<java.lang.Integer> getPrimes(int min,int max) throws IllegalArgumentException{
    
23.                 /*参数不合法抛出异常*/
    
24.                 if(min < 0)throw new IllegalArgumentException("参数min:"+min+"不合法！");
    
25.                        
    
26.                 if(min > max) throw new IllegalArgumentException("参数min:"+min+",不能大于max:"+max);
    
27.                
    
28.                 /*确保min是从奇数开始*/
    
29.                 if(min % 2 == 0) min++;
    
30.                
    
31.                 /*新建一个集合用于容纳min到max范围中的素数*/
    
32.                 List<java.lang.Integer> primes = new ArrayList<java.lang.Integer>();
    
33.                
    
34.                 /*外层循环主要控制min到max范围中所有奇数*/
    
35.                 while(min<=max)
    
36.                 {
    
37. 
    
38.                         int sqrt =(int)Math.sqrt(min); //求出当前数的据平方根
    
39.                        
    
40.                         int find = 2;  //查找因数从2开始,小于等于当前数的平方根
    
41.                        
    
42.                         while(find++ <= sqrt)
    
43.                                 if(min % find==0)break;  //找到因数，跳出循环
    
44.                        
    
45.                        
    
46.                         if(find > sqrt)  //没找到表示是素数
    
47.                                 primes.add(min);
    
48.                        
    
49.                         min+=2;
    
50.                 }
    
51.                        
    
52.                 return primes;
    
53.                
    
54.         }
    
55.        
    
56.         /***
    
57.          * 打印所有素数
    
58.          * @param primes
    
59.          */
    
60.         public static void primesShow(List<java.lang.Integer> primes){
    
61.                 for (java.lang.Integer integer : primes) {
    
62.                         System.out.print(integer+",");
    
63.                 }
    
64.         }
    
65. }
    

复制代码

思路说下：一个循环，i 从2~100，分别判断 i 能否被2~（i-1）整除，若都不能整除，则为质数。

都很厉害，来学习了

楼上说的不错

使用2层for循环，如下，当然也可以单独封装成方法

1. for(int i=2;i<=100;i++)  //遍历2至100间的整数
   
2.                 {
   
3.          if(i==2)  //2为质数，直接打印
   
4.                 System.out.println(i);
   
5.          for(int j=2;j<i;j++)   //判断该整数i能否被2至i-1的数整除，及打印2以后的质数
   
6.          {  
   
7.                if(i%j==0)
   
8.                       break;
   
9.                if(i==j+1)
   
10.                      System.out.println(i);

复制代码

都忘了什么是质数了，来学习学习。

public static List<Integer>  getPrime(int start,int end)        {
                List <Integer> list =new ArrayList<Integer>();
                if(start==1){
                        list.add(1);
                        start++;
                }if(start==2){
                        list.add(2);
                        start++;
                }if(start==3){
                        list.add(3);
                        start++;
                }if(start>=end){
                        throw new RuntimeException("请保证后面的参数大于前面的参数");
                }
                int temp =(int)Math.sqrt(end);
                for(int i=start;i<=end;i++){
                        for(int j=2;j<=temp;j++){
                                if(i%j==0){
                                        break;
                                }
                            if(j>=temp){
                                         list.add(i);
                                }
                        }        
                }        
                        return list;        
        }
        public static void main(String []args){
                int count =0;
                List<Integer> list =getPrime(100,300);
                System.out.println("输入的范围内共有"+list.size()+"个素数");
                for(int each:list){
                        count++;
                        System.out.print(each+" ");        
                        if(count%10==0){
                        System.out.println();
                        }
                }
        }
}
我的循环思路是比较到了大数的平方根后就不再进行比较了。这样可以少比较很多次，有利于提高代码运行效率。。

悲催，已经不知道什么叫质数了，只记得好多年前学过，如果我考到就挂了，不懂质数直接没思路的说

public class Test5 {
        public static void main(String[] args) {
                checkPrime(2,100);//将需要判断的范围传给chickPrime，包含头，不含尾        
        }
        
        public static void checkPrime(int min,int max) { //判断一个范围之间的质数，并打印。
   
                if(min%2==0)//确保从范围内的第一个奇数开始判断
                        min++;
                for(int i=min;i<max;i=i+2 ){ //判断min和max之间的奇数     
                        if(isPrime(i)) //调用isPrime判断是否为质数,是则输出
                                System.out.println(i);            
                }
        }
        private static boolean isPrime(int max){       //判断一个数是否是质数
                for(int i=2;i<max;i++){       //循环起始为除数的范围，即（1，max）的开区间  
                        if(max%i==0) {     //不能被2至max-1所有数整除，则为质数
                                return false;
                        }
                }
                return true;
       }
}