public static void main(String[] args) {
		int count=0;            
		
	for(int i=2;i<=10000000;i++){
		int ci=0;                
		for(int k=1;k<=i;k++){  
			if(i%k==0 ){		
				ci++;           
			}
		}
		if(ci==2){             
			System.out.println(i);
			count++;	           
		}
	}
		
	System.out.println("质数为"+count+"个");
		

import java.util.Scanner;
class  Prime{

	public int getTotalNumber(int n ){
		int total = 0;
		int []a = new int [n+1];

		for(int i =0 ; i<n+1 ;i++){
			a[i] = 1;
		}
		for(int j =2 ; j<n+1 ; j++){
			if(a[j] ==1 ){
				for(int k = 1; k * j <= n ; k++){
					a[j*k] = 0;
				}
				total++;
			}
		}

		return total;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("Please input the number: ");
		int number = in.nextInt();
		long startTime = System.currentTimeMillis();
		Prime pr = new Prime();
		System.out.println(pr.getTotalNumber(number));
		long endTime = System.currentTimeMillis();
		System.out.println("Time : "+(endTime-startTime)+" ms");
	}
		
}

public class TestNumber3 {
	public static void main(String[] args) {
        float f1 = 5.4f;
        float f2 = 5.5f;
        //5.4四舍五入即5
        System.out.println(Math.round(f1));
        //5.5四舍五入即6
        System.out.println(Math.round(f2));
         
        //得到一个0-1之间的随机浮点数（取不到1）
        System.out.println(Math.random());
         
        //得到一个0-10之间的随机整数 （取不到10）
        System.out.println((int)( Math.random()*10));
        //开方
        System.out.println(Math.sqrt(9));
        //次方（2的4次方）
        System.out.println(Math.pow(2,4));
         
        //π
        System.out.println(Math.PI);
         
        //自然常数
        System.out.println(Math.E);
        System.out.println("------------------");
       double i=Math.random()*1000000000;
       double ii=Math.pow((1+ 1/i),i);
       System.out.println(ii);
    }

}

public static void main (String[] args) {
		int sum=2;
		for(int i=4;i<=100;i++) {
			
			int k=1;
			double sqrt=Math.sqrt(i);
			double a=Math.round(sqrt);
			
			for(int j=2;j<=a;j++) {
				if(i%j!=0) {
					k++;
				}
			if(k==a) {
				sum++;
			}
						

	{
	int sum = 0,l;
	double d;
	for(int i=2;i<10000001;i++) {
		d =Math.sqrt(i);
		for(l=2;l<=d;l++) {
			if(i%l ==0) {
				break;
			}
		}
		if(l>d) {
			sum++;
		}
	}
	System.out.println("一千万以内的质数一共有："+sum）;
	}

package digit;
 
public class TestNumber {
 
    public static void main(String[] args) {
         
        int max = 10000*1000;
        int count = 0 ;
        for (int i = 1; i <=max; i++) {
            if(isPrime(i)){
                count++;
            }
        }
        System.out.println("一千万以内的质数一共有 : " + count);
 
    }
 
    private static boolean isPrime(int i) {
        for (int j = 2; j <= Math.sqrt(i); j++) {
            if(0==i%j)
                return false;
        }
        return true;
    }
     
}

package sheji;

/**
* Copyright © 2018 GaoShang. All rights reserved
*
* @author GaoShang
* @date 2018年11月10日
*/

public class HelloWorld {
	
	public static void main(String[] args) {
		int num	 = 0; //计数器
		//计算一千万合数的数量
		for (int i = 2; i <= 1e7; i++) 
				for (int j =2; j <= Math.sqrt(i); j++) 
					if (i % j == 0) {
						num++;
						break;
					}
		//素数数量为总数减去合数
		System.out.println(1e7-num);		
	}
}

package sheji;

/**
* Copyright © 2018 GaoShang. All rights reserved
*
* @author GaoShang
* @date 2018年11月7日 下午4:28:20
*/


public class HelloWorld {
	
	public static void main(String[] args) {
		int num	 = 0;
		
		for (int i = 2; i <= 1e7; i++) 
				for (int j =2; j <= Math.sqrt(i); j++) 
					if (i % j == 0) {
						num++;
						break;
					}
		
		System.out.println(1e7-num);		
	}
}

package charactor1;

public class Text {
	public static void main(String[]args){
		int k=10000000,c=0,j;
		if(k>=2)
		{
			System.out.print(2+"\t");c++;
		
			for(int i=3;i<k;i++)
				{
				for(j=2;j<Math.sqrt(i);j++)
					{
					if(i%j==0)
						{
						break;
						}
					}
				if(j>Math.sqrt(i))
					{System.out.print(i+"\t");
					c++;
			if(c%15==0)//不要这个应该能快一丢丢
		             	{System.out.println("");
                                }
					}
				}
		System.out.println("\n总数："+c);
		}
	}
}

package digit;

public class SingerData {
    boolean is_true;
    int max = 10000000;
    int count = 0;

    public void FindData() {
        for (int i = 1; i <= max; i++) {
            is_true = false;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    is_true = true;
                    break;
                }
            }
            if (is_true) {
                continue;
            }
//            System.out.println(i);
            count++;
        }
    }

    public static void main(String[] args) {
        SingerData s = new SingerData();
        s.FindData();
        System.out.println(s.max + "以内一共有" + (s.count+1) + "个质数");
    }
}

public class Anumber {
	public static void main(String[] args) {
		int total = 0; // 质数总数
		boolean b = true;

		for (int i = 2; i <= 10000000; i++) {
			String str = String.valueOf(i);
			String sub = str.substring(str.length() - 1);
			if (sub != "0" && sub != "2" && sub != "4" && sub != "5" && sub != "6" && sub != "8") {
				for (int j = 2; j <= (int) Math.sqrt(i); j++) {
					// 如果有除了1和本身以外的数能整除自己
					if (i % j == 0) {
						b = false;
						break;
					}
				}
			}
			if (b == false) {
				b = true;
				continue;
			}
			total += 1;
			System.out.print(i + ",");
			if (total % 10 == 0) {
				System.out.println();
			}
		}
		System.out.println("\n一千万以内的质数一共有：" + total + "个");
	}
}

public class ZhiShu {
	
		public static boolean isprime(int i){
		for(int j=2;j<=Math.sqrt(i);j++){
			if(i%j==0){
				return false;
		}
		}return true;
}

		public static void main(String[] arg){
		int count=0;
		for(int i=1;i<10000000;i++)
		{			
			if(isprime(i)){
		    count++;
				}	
			
		}System.out.println("一共有"+count+"个质数");
		
}
		}

package com.java.Test;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 
 * 统计找出一千万以内，一共有多少质数
 * 
 * @author 王*
 *
 */
public class TestZhiShu {
	public static void main(String[] args) {
		System.out.println("请输入统计的范围");
		Scanner sca = new Scanner(System.in);
		int number = sca.nextInt();
		while(number<2) {
			System.out.println("请重新输入范围:");
			number = sca.nextInt();
		}
		int count = 0;
		int[] iArr = new int[number];
		Arrays.fill(iArr, 1);
		for(int i = 2; i<iArr.length; i++) {
			if(iArr[i]==1) {
				for(int j = 2; j*i<iArr.length; j++) {
					iArr[i*j] = 0;
				}
				count++;
			}
		}
		System.out.println("质数数量："+count);
	}
}

/**
 * java.lang.Math提供了一些常用的数学运算方法，并且都是以静态方法的形式存在
 * @author Chen
 */
public class IndexController {
	public static void main(String[] args) {
		/**
		 * 题目一：
		 * 自然对数的计算方式
		 * 借助Math的方法，把自然对数计算出来，看看经过自己计算的自然对数和Math.E的区别有多大
		 */
		System.out.println(Math.E);
		int n = Integer.MAX_VALUE;
		double db = (Math.pow(1+(1.0/n), n));
		System.out.println(db);
		
		/**
		 * 题目二：
		 * 质数
		 * 统计找出一千万以内，一共有多少质数
		 * 质数概念: 只能被1和自己整除的数
		 */
		int num = 1000 * 10000;
		int count = 0;
		for (int i = 2; i <= num; i++) {
			if(isPrime(i)) {
				count++;
			}
		}
		System.out.println("一共" + count + "质数");
	}
	
	public static boolean isPrime(int i) {
		for (int j = 2; j <= Math.sqrt(i); j++) {
			if(i % j == 0) {
				return false;
			} 
		}
	return true;
	}
}

/*-----------笔记-------------
 * 	Math.round() 	四舍五入
 * 	Math.random()	随机数
 *  Math.sqrt()		开方
 *  Math.pow()		次方
 *  Math.PI			π
 *  Math.E 			自然常数 
 */

public static void A2() {
	System.out.print("1");
	int s=1;
    for(int i=2;i<10000000;i++) {
    	int k=0;
    	for(int j=1;j<=i;j++) {
    		if(i%j==0) {		
    		k++;
    		}	
    	}
    	if(k==2) {
    	//System.out.print(","+i);
    	s++;
    	}
    }
    System.out.println("10000000以内质数的个数为:"+s);
}

//练习，数学方法
public class HelloWorld{
	public static void main(String[] args) {
		int i=Integer.MAX_VALUE;
		System.out.println(Math.E);
		System.out.println(Math.pow((1+1d/i),i));
	}
}
//练习，求质数
public class HelloWorld{
	public static void main(String[] args) {
		int n=0;
		for(int i=2;i<10000000;i++) {
			if(pd(i))
				n++;
		}
		System.out.println(n);
	}
	static boolean pd(int n) {
		int k=(int)Math.sqrt(n);
		if(n==2) {
			return true;
		}
		for(int i=2;i<=k;i++) {
			if(n%i==0)
				return false;
		}
		return true;
	}
}

public class 一千万以内的质数 {
	public static void main(String[] args) {
		int num = 10000000;
		int count = 0;
		// 所谓质数就只能被1和它本身整除的数.所有大于10的质数中,个位数为1,3,7,9.
		// 另外,如果一个非质数是N,那么这个数从2到根号N之间的数,一定有能除尽的数.
		//因为1不是质数,所以从2开始
		a:for (int i = 2; i < num; i++) {
			// 选出大于10的,个位数是1,3,5,7,9的数,只有这些数才有可能是质数
			if (i > 10 && (i % 10 == 1 || i % 10 == 3 || i % 10 == 7 || i % 10 == 9)) {
				// 如果有能除尽的数就继续循环a;否者这个数就是质数,count++
				 for (int j = 2; j <= Math.sqrt(i); j++) {
					if (i % j == 0) {
						continue a;
					}
				}
				count++;
				System.out.println("第" + count + "个素数");
			} else if(i<=10){
				// 计算1到10之间的质数
					for (int j = 2; j < i; j++) {
					if (i >= 3 && i % j == 0) {
						continue a;
					}
				}
				count++;
				System.out.println("第" + count + "个素数");
			}
		}
		System.out.println("10000000以内的质数有:" + count + "个");
	}
}

public class 一千万以内的质数 {
	public static void main(String[] args) {
		int num = 10000000;
		int count = 0;
		// 所谓质数就只能被1和它本身整除的数.所有大于10的质数中,个位数为1,3,7,9.
		// 另外,如果一个非质数是N,那么这个数从2到根号N之间的数,一定有能除尽的数.
		a:for (int i = 1; i < num; i++) {
			// 选出大于10的,个位数是1,3,5,7,9的数,只有这些数才有可能是质数
			if (i > 10 && (i % 10 == 1 || i % 10 == 3 || i % 10 == 7 || i % 10 == 9)) {
				// 如果有能除尽的数就继续循环a;否者这个数就是质数,count++
				 for (int j = 2; j <= Math.sqrt(i); j++) {
					if (i % j == 0) {
						continue a;
					}
				}
				count++;
				System.out.println("第" + count + "个素数");
			} else if(i<=10){
				// 计算1到10之间的质数
					for (int j = 2; j < i; j++) {
					if (i >= 3 && i % j == 0) {
						continue a;
					}
				}
				count++;
				System.out.println("第" + count + "个素数");
			}
		}
		System.out.println("10000000以内的质数有:" + count + "个");
	}
}

class ZhiShu{
	//判断是否为质数的静态方法
	static boolean isZhiShu(int n){
		for(int i=2;i<n;i++){
			if(n%i == 0){
				return false;
			}
		}
		return true;
	}
}

//以下是main中执行的代码
		int sum=0;//统计质数个数
		
		for(int i=2;i<Math.pow(10, 6);i++){
			if(ZhiShu.isZhiShu(i)){
				sum+=1;
			}
		}		
		System.out.println("质数有"+sum);

public class 练习质数 {
//取一千万以内的质数 --先写一个方法来判断某一个数是不是质数。
 //然后做一个循环 取（2-10000000）中的每一个数代入该方法中，作为要判断的数。
	
	public static boolean fangfa(int i) {    //静态方法、返回类型为布尔值、i即是需要代入的数  
		for(int j=2;j<= Math.sqrt(i);j++) {  //被除数j、从2开始至被代入数的开方、=号表示包括开方本身
			
 //开方是因为节约计算次数，若某个数能被整除（不包括1与本身），那么2至该数开方之间（包括开方）一定有一个能被整除的数。
 //例i=45,i的开方约6.7，那么2-6.7之间，有3 与5，这两个数都能被45整除 而不用计算 6.7之后的数，比如15。	
			if(i%j==0) {                     //如果代入数÷被除数 余数是0
				return false;                //那么返回的布尔值是false
			}
		}
		return true;	                     //若if条件不成立，则返回true
	}                                        //“判断某个数是不是质数” 方法 结束
	                                         //if语句成立，代入数不是质数，不成立则是质数，且返回true
	
	public static void main(String[] args) {
		int s1=0;                            //临时值
		练习质数 s=new 练习质数();
		for(int e=2;e<10000*1000;e++) {		 //代入数e	2-10000000
			if(s.fangfa(e)) {                //每次循环将e代入该方法中来判断是不是质数
				s1++;                        //if语句若为 true 那么这里s1自增一次，若为false,则会继续循环
			}
		}	
		System.out.println(s1);              //计算时间较长...
}
}

public class 练习质数 {
	 //取一千万以内的质数 --先写一个方法来判断某一个数是不是质数。
	 //然后做一个循环 取（2-10000000）中的每一个数代入该方法中，作为要判断的数。
	
	public static boolean fangfa(int i) {                          //静态方法、返回类型为布尔值、i即是需要代入的数  
		for(int j=2;j<= Math.sqrt(i);j++) {                      //被除数j、从2开始至被代入数的开方、=号表示包括开方本身
			
         //开方是因为节约计算次数，若某个数能被整除（不包括1与本身），那么2至该数开方之间（包括开方）一定有一个能被整除的数。
	 //例i=45,i的开方约6.7，那么2-6.7之间，有3 与5，这两个数都能被45整除 而不用计算 6.7之后的数，比如15。	
			if(i%j==0) {                                              //如果代入数÷被除数 余数是0
				return false;                                    //那么返回的布尔值是false
			}
		}
		return true;	                                               //若if条件不成立，则返回true
	}                                                                              //“判断某个数是不是质数” 方法 结束
	                                                                               //if语句成立，代入数不是质数，不成立则是质数，且返回true
	
	public static void main(String[] args) {
		int s1=0;                                                         //临时值
		练习质数 s=new 练习质数();
		for(int e=2;e<10000*1000;e++) {		       //代入数e	2-10000000
			if(s.fangfa(e)) {                                       //每次循环将e代入该方法中来判断是不是质数
				s1++;                                              //if语句若为 true 那么这里s1自增一次，若为false,则会继续循环
			}
		}	
		System.out.println(s1);                                    //计算时间较长...
}
}

public class Shuxue1 {//未完善
    public static void main(String[] args) {
        int count = 0;
        for (int i=2;i<100;i++){
            if (zhisu(i)){
                count++;
            }
        }
        System.out.println("质数一共有"+count+"个");
    }
    public static boolean zhisu(int i){
        //boolean zs = true;
        for (int j = 2;j<=Math.sqrt(i);j++){//j<=Math.sqrt(i)，i为2,3时，j>Math.sqrt(i)。所以2,3的时候，return true
            if (i%j == 0){
                // zs=false;
                return false;
            }

        }
        return true;
        //  return zs;
    }
}

package character;

/*
 统计找出一千万以内，一共有多少质数

 质数概念: 只能被1和自己整除的数
 举例:
 5只能被 1和5整除，所以是质数
 8可以被2整除，所以不是质数   
 */
public class Test {
	public static void main(String[] args) {
		String str = "100以内的质数个数为: %s 个数";
		System.out.println(String.format(str, numbers(100)));
		
	}
	// 判断是否是质数
	public static boolean isPrime(int n) {
		if(n < 2) return false;
		for (int i = 2; i < n; i++) {
			if (n % i == 0)
				return false;
		}
		return true;
	}
	// 找出指定数值质数的个数
	public static int numbers(int number) {
		int count = 0;
		for (int i = 1; i <= number; i++) {
			if (isPrime(i)) {
				count++;
				System.out.print(showPrime(i,count));
			}
		}
		return count;
	}
	// 展示质数
	public static String showPrime(int value,int count) {
		String str = null;
		str = value+"  ";
		if(count % 5 == 0) {
			str += "\n";
		}
		return str;
	}
}

public class TestNumber {
    public static void main(String[] args) {
        double e = 1, sum = 1;
        // Double.POSITIVE_INFINITY顾名思义，代表正无穷
        for (int i = 1; i < (int) Double.POSITIVE_INFINITY; i++) {
            sum *= i;
            e += 1.0 / sum;
        }
        System.out.println(e);
        System.out.println(Math.E);
    }
}

private static boolean isPrime(int i) {
        for(int j=2;j<=Math.sqrt(i);j++){
            if(i%j==0){
                return false;
            }
        }
         
        return true;

public class Test {
	public static void main(String[] args) {
		System.out.println(Math.E);
		double x=Double.MAX_VALUE;
		double s=Math.pow(1+1.0/x, x);
		System.out.println(s);
	}
}
2.718281828459045
1.0

package digit;

public class TestNumber {

	public static void main(String[] args) {
		
		int max = 10000*1000;
		int count = 0 ;
		for (int i = 1; i <=max; i++) {
			if(isPrime(i)){
				count++;
			}
		}
		System.out.println("一千万以内的质数一共有 : " + count);

	}

	private static boolean isPrime(int i) {
		for (int j = 2; j <= Math.sqrt(i); j++) {
			if(0==i%j)
				return false;/////这里若执行这个语句，就跳出这个循环语句，boolean的值就是false了么？？？，也就相当于break么？？？
		}
		return true;
	}
	
}

我的代码：
                int i = 1;
		int n = 7;
		System.out.println("自己计算的自然对数:"+Math.pow(i+i/n, n));
		System.out.println("Math.E:"+Math.E);


老师你的代码：
        System.out.println(Math.E);
        int n = Integer.MAX_VALUE;
        System.out.println(     Math.pow(1+1d/n,n));    

package test;

public class Test {

	public static void main(String[] args) {

		System.out.println("I love you");
		int n = 0;
		int count = 0;
		for (n = 1; n < 1000 * 10000; n++) {
			for (int i = 2; i <= (int) (Math.sqrt(n)); i++) {
				if (0 == n % i) {
					break;
				} else {
					if ((int) (Math.sqrt(n)) == i) {
						// System.out.println(n);
						count = count + 1;
					}
				}
			}

		}
		System.out.println(count + 2);
	}

}

        int count=0,n=10000000;
        double m=Math.sqrt(n+0.5);
        int[]vis=new int[n];
        for(int i=2;i<m;i++)
            if(vis[i]==0)
                for(int j=i*i;j<n;j+=i)
                    vis[j]=1;

        for(int i=1;i<n;i++)
            if(vis[i]==0)
                count++;

package com.digit;

public class TestNumber {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int l = Integer.MAX_VALUE;
		double d = (double)l;
		double e = Math.pow((1+1/d), d);
		System.out.println(e);
		System.out.println(Math.E);
	}

}

        int max =1000;   //判断范围
        long count = 0l; //计数
        //给定需要判断的数，因为1本身不是质数，所以从2开始
        for(int i =2; i<=max; i++){
        	//判断一个数是不是素数
        	for(int j=2; j<=i; j++){
        		//从2开始到这个数是否还能被其他数整除
        		if(i%j == 0){
        			//如果能整除，判断这个数是不是本身，如果是  说明是素数，计数加1
        			if(i == j)
        				count++;
        			break;
        		}
        	}
        }
        
        System.out.println("个数是:"+count);

private static boolean isPrime(int i) {
        for (int j = 2; j <= Math.sqrt(i); j++) { 
            if(0==i%j)
                return false;
        }
        return true;

    public static void main(String[] args) {
     float m=Float.MAX_VALUE;
    int n=Integer.MAX_VALUE;
     System.out.println(Math.pow((1+1d/m),m));
        System.out.println(Math.pow((1+1d/n),n));
        System.out.println(Math.E);

  int n = Integer.MAX_VALUE;
        System.out.println(     Math.pow(1+1d/n,n));    

没有异常。。就是没有看懂。。

        int number=1000*10000;
        int record=1;
        for(int i=2;i<=number;i++){
            boolean flag=true;
        	for(int j=2;j<=(int)Math.pow(i, -2);j++){
        		if(i%j!=0){
        			flag=false;
        			break;
        		}
        	}
        	if(flag)
        		record+=1;