public class Test9 {
        public static void main(String[] args){
                //定义一个数组
                long[] a=new long[501];
                 int i=2,j=1;
                a[1]=1;
        //往数组里存放数，如1*2 3*4 5*6 7*8 9*10这样只用500个数组空间就OK了
        while(i<=1000){
                a[j]=i*(++i);
                j++;i++;
        }
        
        int z=0;
        //在建一个for循环调出数组里的数
        for(int c=1;c<=500;c++){
                //判断是否是后面有零的数
                if(a[c]%10!=0){
                        continue;
                }
                //如果后面有零，那么Z就累加。之后清除0继续判断
                while(a[c]%10==0){
                     z++;
                     a[c]=a[c]/10;
                        
                }}
                System.out.println(z);
                        
        }}
这个程序对么。
运行结果：223

你求的不是1000的阶乘吧。

错了错了，这道题我做过，就是结尾也不止223个，何况全部的。

star5603 发表于 2014-7-26 15:42
错了错了，这道题我做过，就是结尾也不止223个，何况全部的。

求解怎么存储超过long范围的整数！！！！！那个包中有该类方法？

hejinzhong 发表于 2014-7-26 16:09
求解怎么存储超过long范围的整数！！！！！那个包中有该类方法？

你如果想算出结果，那就用BIgInteger类，然后遍历一个一个数。
如果找规律（只有尾部有规律，全部的不行），凡5倍数（包括5）会在末端产生1个0，25产生2个0，125三个0,625四个0。。。
还有一种方法，可以算全部，也可以算尾部，你把每一次计算的结果用数组存，一个元素存一位，例如4！= 24；那就让arr[0]=4,arr[1] = 2;（倒过来的），把算5！的话，就把5乘以4！的数组每一位，超过10的，往后推，每一个元素只能存0-9的数字。数组长度先定个10000吧，够了。
估计你不怎么懂，我说的比较烂。。。

1. package com.itheima;
   
2. 
   
3. import java.math.BigInteger;
   
4. import java.util.regex.Matcher;
   
5. import java.util.regex.Pattern;
   
6. /**
   
7. * 求1000！的结果中包含多少个0
   
8. * 1000! = 1×2×3×4×5×...×999×1000
   
9. */
   
10. public class Test9 {
    
11. 
    
12.         public static void main(String ars[]) {
    
13.                 Test9 test9 = new Test9();
    
14.                 test9.jieCheng(1000);
    
15.         }
    
16.         //将阶乘的数学运算原理封装成对象
    
17.         public void jieCheng(int number) {
    
18.                 //创建一个大数对象
    
19.                 BigInteger res = new BigInteger("1");
    
20.                 //利用循环计算1000!的值
    
21.                 for (int i = 1; i <= number; i++) {
    
22.                         BigInteger num = new BigInteger(String.valueOf(i));
    
23.                         // 相当于res * = num;，但是大数不是基本数据类型，不能使用*运算符，用独有的方法
    
24.                         res = res.multiply(num);
    
25.                 }
    
26.                 //将获得的值转成字符串
    
27.                 String str = res.toString();
    
28.                 //调用方法，获取res中一共有多少个0
    
29.                 int zeroNum = zeroNum(str);
    
30.                 //输出结果
    
31.                 System.out.println(number + "的阶乘为：" + "\n" + str);
    
32.                 System.out.println(number + "的阶乘中所有的0的个数：" + zeroNum);
    
33.         }
    
34. 
    
35.         // 求阶乘结果所有的0的个数
    
36.         public int zeroNum(String str) {
    
37.                 int count = 0;
    
38.                 String regex = "0";
    
39.                 Pattern p = Pattern.compile(regex);
    
40.                 Matcher m = p.matcher(str);
    
41.                 while (m.find()) {
    
42.                         count++;
    
43.                 }
    
44.                 return count;
    
45.         }
    
46. }

复制代码

嘛 这道题我基础考试的时候做过 你参考一下吧

1. private static void func() {
   
2.         BigInteger num = BigInteger.valueOf(1);
   
3.         for (int i = 1; i < 1001; i++) {
   
4.                 num = num.multiply(BigInteger.valueOf(i));
   
5.         }
   
6.         System.out.println(num);
   
7.        
   
8.         int count = 0;
   
9.         char[] b = num.toString().toCharArray();
   
10.         for (char c : b) {
    
11.                 if (c == '0')
    
12.                         count++;
    
13.         }
    
14.         System.out.println(count);
    
15. }

复制代码

结果 472
考虑到 9*12=108 ，中间的 0 应该没有规律，分段计算应该不行，况且就算只算末尾的 0 ，也要考虑分段计算的结果中末尾为 2 和 5 的结果继续相乘计算

star5603 发表于 2014-7-26 16:19
你如果想算出结果，那就用BIgInteger类，然后遍历一个一个数。
如果找规律（只有尾部有规律，全部的不行 ...

我也是这么想的，让数组分别记住每位的数字，各自去算

123456789654

学习了。。。。

我也是查了好久,对各种解决方法似懂非懂

不明觉厉，但还是不太懂

不太懂，大数这个没怎么学。。。

icris 发表于 2014-7-26 17:17
结果 472
考虑到 9*12=108 ，中间的 0 应该没有规律，分段计算应该不行，况且就算只算末尾的 0 ，也要考 ...

黑马牛人就是多，这是我第一次使用BigInteger这个数据类型，精度没有限制，太强大了。

那份的哦。。

晕死  自己弄得那循环断不了。
学习了

这题很变态，看看，，，

醉、倾鯎 发表于 2014-7-26 17:05
嘛 这道题我基础考试的时候做过 你参考一下吧

这个题对了吗？

也可以这样理解问题，一个数 n 的阶乘末尾有多少个 0 取决于从 1 到 n 的各个数的因子中 2 和 5 的个数, 而 2 的个数是远远多余 5 的个数的, 因此求出 5 的个数即可。

看得头晕了·······还须努力了·