黑马程序员技术交流社区

标题: 金额转换,阿拉伯数字转换成中国传统形式。 [打印本页]

作者: 李大伟    时间: 2013-4-6 13:19
标题: 金额转换,阿拉伯数字转换成中国传统形式。
本帖最后由 李大伟 于 2013-4-9 09:14 编辑

金额转换,阿拉伯数字转换成中国传统形式。
                 例如:101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整


这个题不会,找了一个 ,但是 输入长了 比如101000001010  就报错了
求大侠指点

public class Test{

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                //输出测试
                System.out.println(getString(405356221));
                System.out.println(getString(11000001010));
        }
        //定义两个数组 给数字做单位
        public static String[] cn={"仟","佰","拾","万","仟","佰","拾","亿","仟","佰","拾","万","仟","佰","拾","圆整"};
        public static String[] number={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        public static String getString(int n)
        {
         String money=""+n;
        //超过长度提醒
        if(money.length()>cn.length)
                throw new IllegalArgumentException("人民币超出计算范围,请重新输入!");
        //定义返回 字符串
        String str="";
        //使用for循环 匹配每个位数上的单位,以及大小写
        for(int i=0;i<money.length();i++)
        str+=number[Integer.parseInt(""+money.charAt(i))]+cn[cn.length-money.length()+i];
        return str;
        }

}



作者: 邵震    时间: 2013-4-6 13:47
你是想输入任意数字都能转换成汉字吗?

这个题好玩 拿去试试  哈哈
作者: 李大伟    时间: 2013-4-6 14:14
邵震 发表于 2013-4-6 13:47
你是想输入任意数字都能转换成汉字吗?

这个题好玩 拿去试试  哈哈

这个是考试题,最起码得能容纳那个例子吧
作者: 陈圳    时间: 2013-4-6 19:52
能容纳这个例子的简单,但是想要真正做到无错转换任意位数的就有些难度了.转换的次数很多.你想要容纳这个位数的我给你一个参考,而且也很简单,但是要做到任一转换,你就自己想吧. 不写了,自己慢慢想吧,我自己的思路,把所有数值切成4等份,然后依次插入:千百十,然后再每个等份再插入万/亿/万亿,每个等份判断里再判断有多少个零.
  1. public static void main(String[] args) {
  2.                 Long num=101000001010L;
  3.                 System.out.println(change(num));
  4.         }
  5.         public static String change(Long num){//long的包装类","因为包装类可以转换成字符串","而Long的范围也可以容纳那个数值
  6.                 String[] list={"零","一","二","三","四","五","六","七","八","九"};
  7. //                String[] nuit
  8.                 char[] nums=num.toString().toCharArray();//数值在ASCII码.
  9.                 StringBuilder numBuilder=new StringBuilder();
  10.                 for(char c:nums)
  11.                         numBuilder.append(list[c-48]);
  12.                 return numBuilder.toString();
  13.         }
复制代码

作者: 王川    时间: 2013-4-8 01:34
public static String[] cn={"", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿"};

当超过8位,也就是在亿以上的时候,又回来循环赋值

当你在各个单位前面赋上零的时候,要处理,将“零拾”,“零佰”等等用零替换,
最后处理连续出现的“零”为一个“零”
……
需要源代码可以给你一个
作者: 黄玉昆    时间: 2013-4-8 08:43
如果问题未解决,请继续追问,如果没有问题了,请将帖子分类 改为“已解决”,谢谢
作者: 我手心里的宝    时间: 2013-4-8 09:01
你这是入学测试压轴题呀 ,胆挺肥呀
作者: 我手心里的宝    时间: 2013-4-8 09:03
package com.itheima;

/**
* 第10题: 金额转换,阿拉伯数字转换成中国传统形式。
*例如:101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整
*
*@author 陈宝峰
*
*步骤:
*1.创建一个转换的方法converNumber(long number)
*2.将阿拉伯形式转换成中国传统形式
*3.去零操作
*4.正则表达式替换操作
*/
public class Test10 {
        public static void main(String[] args){
                //测试
                System.out.println(convertNumber(3500908));
                System.out.println(convertNumber(101000001010L));
        }
        public static String convertNumber(long number){
                //定义字符数组存储中国数字写法格式
                final char[] chineseNumber = new char[]
                { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
                //定义字符数组存储中国数字的单位
                final char[] units = new char[]
                { '圆', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟'};
                //定义一个字符串缓冲区对字符进行存储
                StringBuilder sb = new StringBuilder();
                int index=0;
                long lastNumber = 0;
                while(number!=0){
                        lastNumber = number%10;
                        sb.insert(0,units[index++]);
                        sb.insert(0,chineseNumber[(int) lastNumber]);
                        number=number/10;
                }
                //去零操作,通过正则表达式
                return sb.toString().replaceAll("零[拾佰仟]","零").replaceAll("零+亿","亿").replaceAll("零{4}万","零").
                replaceAll("零+万","万").replaceAll("零+圆","圆").replaceAll("零+","零")+"整";
        }

}
我感觉我这个很简练,各位也挑挑毛病吧
作者: 李大伟    时间: 2013-4-8 14:12
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

我这个 真心不会啊,这个是压轴的啊,我说这么难呢
作者: 李大伟    时间: 2013-4-8 14:16
王川 发表于 2013-4-8 01:34
public static String[] cn={"", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿"};

当超过8位,也就是在 ...

需要啊 ,看看,谢谢了
作者: 王海龙2013    时间: 2013-4-8 14:23
真胆肥啊,这个也敢拿出来问
作者: 李大伟    时间: 2013-4-8 14:30
王海龙2013 发表于 2013-4-8 14:23
真胆肥啊,这个也敢拿出来问

这个没什么吧,我确实不会,不会就问问,与其去百度里边问陌生人,在论坛里边大家都讨论讨论不是更好吗,我觉得学校也应该支持这种公开讨论吧,
作者: 王川    时间: 2013-4-8 20:34
李大伟 发表于 2013-4-8 14:16
需要啊 ,看看,谢谢了

public class Test10 {
        public static void main(String[] args) {
                /*由于直接用整数表示要转换的大数不好表示,所以,将式子表示成字符串型*/
                String moneyString = "101000000010";
               
                System.out.println(transform(moneyString));
        }

        /**
         *
         * @param moneyString 传入的待转换字符串
         * @return 转换好的字符串
         */
        public static String transform(String moneyString) {
                /* 定义中文大写的数组 */
                String[] chineseUpcase = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
                                "玖" };

                /* 定义换算单位 */
                String[] unit = { "", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿" };

                StringBuilder builder = new StringBuilder();

                /**
                 * 依次替换数字为大写,并给每位赋一个单位
                 */
                for (int i = 0; i < moneyString.length(); i++) {
                        /*
                         * 按照出现的数字,依次替换成大写汉字,在ASCII码中,数字0对应的字符编码是48,
                         * 所以,得到了字符,就应该减去48以换算成相应的数字值
                         */
                        builder.append(chineseUpcase[moneyString.charAt(i) - 48]);
                }

                int pointer = 1;
                for (int j = moneyString.length() - 1; j > 0; j--) {
                        /* 从最低位开始依次在每位后面加上各自代表的位数,拾位,佰位,仟位等 */
                        builder.insert(j, unit[pointer++]);
                        /* 在亿位之后又重新开始循环 */
                        if (pointer == 9)
                                pointer = 1;
                }

                /**
                 * 对出现的零和单位的特殊情况做处理
                 *
                 *replace(int start,int end,String str)
                                        start - The beginning index, inclusive.
                                        end - The ending index, exclusive.
                                        str - String that will replace previous contents.
                 */
                /* 当十位为零时,用"零"代替"零拾" */
                while (builder.indexOf("零拾") != -1) {
                        builder.replace(builder.indexOf("零拾"), builder.indexOf("零拾") + 2, "零");
                }

                /* 当百位为零时 */
                while (builder.indexOf("零佰") != -1) {
                        builder.replace(builder.indexOf("零佰"), builder.indexOf("零佰") + 2, "零");
                }

                /* 仟位为零 */
                while (builder.indexOf("零仟") != -1) {
                        builder.replace(builder.indexOf("零仟"), builder.indexOf("零仟") + 2, "零");
                }

                /* 万位为零,需要保留“万”*/
                while (builder.indexOf("零万") != -1) {
                        builder.replace(builder.indexOf("零万"), builder.indexOf("零万") + 2, "万");
                }

                /* 亿位为零 */
                while (builder.indexOf("零亿") != -1) { // 同上
                        builder.replace(builder.indexOf("零亿"), builder.indexOf("零亿") + 2, "亿");
                }

                /********* 特殊情况,当有亿和万碰到一起的时候,如:100002345 **********/
                while (builder.indexOf("亿万") != -1) {
                        builder.replace(builder.indexOf("亿万"), builder.indexOf("亿万") + 2, "亿零");
                }
               
                /* 有连续的零时,保留一个零 */
                while (builder.indexOf("零零") != -1) {
                        builder.replace(builder.indexOf("零零"), builder.indexOf("零零") + 2, "零");
                }

                /* 当结尾为零时,不显示,经过上面对“零零”的处理,只可能出现一个零 */
                while (builder.lastIndexOf("零") == builder.length() - 1) {
                        /*这里的参数,end,最好不要写成builder.length,防止方法移动后,后面添加的东西也被删除了*/
                        builder.delete(builder.lastIndexOf("零"), builder.lastIndexOf("零") + 1);
                }
                builder.append("圆整");
               
                return builder.toString();
        }
}
作者: 黄玉昆    时间: 2013-4-9 08:05
如果问题未解决,请继续追问,如果没有问题了,请将帖子分类 改为“已解决”,谢谢
作者: hzhzhen    时间: 2015-6-1 23:36
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

学习了。。。。。。。。。
作者: LSK~    时间: 2015-6-8 21:11
正则表达式不简单啊
作者: 星辉祝愿    时间: 2015-6-12 08:24
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

不错啊:)。。。。。。。。。。
作者: j420984    时间: 2015-6-29 08:35
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

还是正则表达式强大。
作者: 拾起落叶    时间: 2015-7-13 16:07
看着有点懵!
作者: zhuhuihui    时间: 2015-8-22 17:38
看蒙了 {:3_49:}
作者: w309940419    时间: 2015-9-21 15:33
我只想说,这道题,我看你们的注释我都没看懂
作者: Mr.CHEN    时间: 2015-9-25 18:06
学习了,顶一个
作者: syusouki    时间: 2015-10-8 19:16
有点不知思路
作者: 陈劲松    时间: 2015-10-13 18:52
本帖最后由 陈劲松 于 2015-10-13 18:55 编辑
  1. package itheima;

  2. import java.util.*;

  3. /*
  4. * 10、 金额转换,阿拉伯数字转换成中国传统形式。

  5. 例如:101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整
  6. * */

  7. /**
  8. * 思路:1.按从键盘录入的数字大小不同分开处理,
  9. *                         每四位每四位进行处理。
  10. *            2.对每四位进行转换,<span style="line-height: 30.7999992370605px;">并判断是否是最后一位,是则不加单位,否则加单位。</span>
  11. *                         <span style="line-height: 30.7999992370605px;">转换结束后根据情况不同添加“萬”或者“亿”单位。</span>
  12. *            3.用正则表达式处理零。
  13. * */
  14. public class Test10
  15. {
  16.         public static void main(String[] args)
  17.         {
  18.                
  19.                 //获取键盘录入,当输入格式错误时提示重新输入。
  20.                 Scanner sc = new Scanner(System.in);
  21.                 System.out.println("请输入12位以内的正整数:");
  22.                 try
  23.                 {
  24.                         long number = sc.nextLong();
  25.                         
  26.                         //将数字转换成中文大写的方法。
  27.                         change(number);
  28.                         Test10.main(args);               
  29.                 }
  30.                 catch(Exception e)
  31.                 {
  32.                         //若输入格式错误,则重新运行主方法。
  33.                         System.out.print("输入格式错误,");
  34.                         Test10.main(args);
  35.                 }
  36.         }
  37.         
  38.         //定义两个字符串数组,分别对应数字的大写整数和单位。
  39.         static String[] ge = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
  40.         static String[] dw = {"拾","佰","仟"};
  41.         
  42.         //将传入的数字转换成中文大写的方法。
  43.         public static void change(long number)
  44.         {
  45.                 String result = "";
  46.                 String yuan = number+"";
  47.                 int lo = yuan.length();
  48.                
  49.                 //按4位数、4~8位数、8~12位数分开处理。
  50.                 if(number<10000)
  51.                 {
  52.                         String yuan1 = yuan;
  53.                         result = qian(yuan1);
  54.                 }
  55.                 if(number<100000000 && number>9999)
  56.                 {
  57.                         String yuan1 = yuan.substring(lo-4);
  58.                         String yuan2 = yuan.substring(0,lo-4);
  59.                         result = qian(yuan2)+"萬"+qian(yuan1);
  60.                 }
  61.                 if(number>99999999)
  62.                 {
  63.                         String yuan1 = yuan.substring(lo-4);
  64.                         String yuan2 = yuan.substring(lo-8,lo-4);
  65.                         String yuan3 = yuan.substring(0,lo-8);
  66.                         result = qian(yuan3)+"亿"+qian(yuan2)+"萬"+qian(yuan1);
  67.                 }
  68.                 //处理零的方法。
  69.                 chuli0(result);
  70.         }

  71.         //处理零的方法。
  72.         public static void chuli0(String result)
  73.         {
  74.                 result = result+"圆整";
  75.                 System.out.println(result.replaceAll("零+圆","圆").replaceAll("零+"
  76.                                 + "萬","萬").replaceAll("零+亿","亿").replaceAll("亿+萬","亿")
  77.                                 .replaceAll("零+","零"));
  78.         }
  79.         public static String qian(String yuan)
  80.         {
  81.                 int lo = yuan.length();
  82.                 String result = "";
  83.                 for(int x=0 ; x<lo ; x++)
  84.                 {
  85.                         int n = yuan.charAt(x)-48;
  86.                         
  87.                         //当不是最后一位且不等于零时,加单位。
  88.                         if(x<lo-1 && n!=0)
  89.                                 result = result+ge[n]+dw[lo-x-2];
  90.                         //当不是最后一位且等于零时,对应零但不加单位。
  91.                         else if(x<lo-1 && n==0)
  92.                                 result = result+ge[n];
  93.                         //当是最后一位且不等于零时,不加单位。
  94.                         else if(x==lo-1 && n!=0)
  95.                                 result = result+ge[n];
  96.                 }               
  97.                 return result;
  98.         }
  99. }
复制代码

作者: HEIMA_CHAO    时间: 2016-2-24 23:02
想了好久,思路有,但是写了好久才做出来,可依然还不完美.来参考下大牛们的方案.
作者: 陌城    时间: 2016-2-25 23:44
厉害厉害,实在是高
作者: asd7227600    时间: 2016-3-1 14:48
谢谢各位热心的回复,学习了很有帮助

正则这么用真是没想到啊...我还是太年轻= _=
作者: 小笼包    时间: 2016-3-1 23:05
考试题,参考一下

作者: fanchunyu    时间: 2016-4-30 13:05
public class Test9 {
        public static void main(String[] args) {
                // 测试
                Scanner sc=new Scanner(System.in);
                long l= sc.nextLong();
                if(l>9999999999999l){
                        System.out.println("数值超过十万亿不能转换");
                }else{
                        System.out.println(convertNumber(l));
                }       
        }
        public static String convertNumber(long number) {
                // 定义字符数组存储中国数字写法格式
                 char[] chineseNumber = new char[] { '零', '壹', '贰', '叁', '肆', '伍',
                                '陆', '柒', '捌', '玖' };
                // 定义字符数组存储中国数字的单位
                 char[] units = new char[] { '圆', '拾', '佰', '仟', '万', '拾', '佰',
                                '仟', '亿', '拾', '佰', '仟' ,'万'};
                //将数值转换为字符串型在转换为字符数组
                char[] nums=Long.toString(number).toCharArray();
                //定义一个可变字符串;
                StringBuffer sb = new StringBuffer();
                int index=0;
                //先将字符串写出
                for (int i = 0; i < nums.length; i++) {
                        sb.insert(0,units[index++]);
                sb.insert(0,chineseNumber[Integer.valueOf(""+nums[nums.length-i-1])]);
                }
                //通过不断的测试去调试字符串,使它符合要求
                return (sb.toString().replaceAll("零[仟佰拾]", "零").replaceAll("[零]+", "零").replaceAll("零亿", "亿").replaceAll("零万", "万")
                                .replaceAll("零圆", "圆").replaceAll("亿万", "亿零")+"整").replaceAll("零圆整", "整");
               
        }
}

作者: a825105162    时间: 2016-5-18 21:45
本帖最后由 a825105162 于 2016-5-18 23:10 编辑
  1. /**
  2. * 第10题、金额转换,阿拉伯数字转换成中国传统形式。 例如:101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
  3. *  分析:具体思路见注释
  4. * @author Administrator
  5. *
  6. */
  7. import java.util.Scanner;

  8. public class Test10 {
  9.         private static Scanner sc;

  10.         public static void main(String[] args) {
  11.                 sc = new Scanner(System.in);
  12.                 // 0-12位的小数
  13.                 System.out.println("请输入要转换的数字(0-12位):");
  14.                 String str = sc.nextLine();
  15.                 // 将str转成long型然后对10000取余得到后四位
  16.                 long lo = Long.parseLong(str);
  17.                 long last = lo % 10000;
  18.                 // 同理可得中间四位以及前面四位
  19.                 long mid = lo / 10000 % 10000;
  20.                 long before = lo / 10000 / 10000 % 10000;
  21.                 // System.out.println(last + "\n" + mid + "\n" + before);
  22.                 // 调用方法得出结果
  23.                 System.out.println("转换后的结果为:" + method(before, mid, last));
  24.         }

  25.         // 可以得出最终结果的方法
  26.         public static String method(long before, long mid, long last) {
  27.                 // TODO Auto-generated method stub
  28.                 // 定义一个空字符串
  29.                 String result = "";
  30. //                System.out.println(before + "--" + mid + "--" + last);
  31.                 // 调用方法得出每一部分的中文输出
  32.                 String before1 = change(before);
  33.                 String mid1 = change(mid);
  34.                 String last1 = change(last);
  35.                 // 如果mid、before、last都为0
  36.                 if (before == 0 && mid == 0 && last == 0) {
  37.                         result = "零圆整";
  38.                 }
  39.                 // 判断如果mid小于等于4、last小于四位数且不为0,before为0
  40.                 else if (before == 0 && mid != 0 && last != 0 && String.valueOf(mid).length() <= 4
  41.                                 && String.valueOf(last).length() < 4) {
  42.                         result = mid1 + "万" + "零" + last1 + "圆整";
  43.                 }
  44.                 // 判断如果mid小于等于4、last等于四位数且不为0,before为0
  45.                 else if (before == 0 && mid != 0 && last != 0 && String.valueOf(mid).length() <= 4
  46.                                 && String.valueOf(last).length() == 4) {
  47.                         result = mid1 + "万" + last1 + "圆整";
  48.                 }
  49.                 // 判断如果before小于等于4且不为0、last小于等于四位数且不为0,mid为0
  50.                 else if (before != 0 && last != 0 && mid == 0 && String.valueOf(before).length() <= 4
  51.                                 && String.valueOf(last).length() <= 4) {
  52.                         result = before1 + "亿" + "零" + last1 + "圆整";
  53.                 }
  54.                 // 判断如果before小于等于4且不为0、mid小于四位数且不为0,last为0
  55.                 else if (before != 0 && last == 0 && mid != 0 && String.valueOf(before).length() <= 4
  56.                                 && String.valueOf(mid).length() < 4) {
  57.                         result = before1 + "亿" + "零" + mid + "万" + "圆整";
  58.                 }
  59.                 // 判断如果before小于等于4且不为0、mid等于四位数且不为0,last为0
  60.                 else if (before != 0 && last == 0 && mid != 0 && String.valueOf(before).length() <= 4
  61.                                 && String.valueOf(mid).length() == 4) {
  62.                         result = before1 + "亿"  + mid + "万" + "圆整";
  63.                 }
  64.                 // 如果mid小于等于四位数且不为0,last和before为0
  65.                 else if (String.valueOf(mid).length() <= 4 && mid != 0 && last == 0 && before == 0) {
  66.                         result = mid1 + "万" + "圆整";
  67.                 }
  68.                 // 如果before小于等于四位数且不为0,mid和last为0
  69.                 else if (String.valueOf(before).length() <= 4 && mid == 0 && last == 0 && before != 0) {
  70.                         result = before1 + "亿" + "圆整";
  71.                 }
  72.                 // 如果last小于等于四位数且不为0,mid和before为0
  73.                 else if (String.valueOf(last).length() <= 4 && mid == 0 && last != 0 && before == 0) {
  74.                         result = last1 + "圆整";
  75.                 }
  76.                 // 如果mid1不小于4位,last1小于四位
  77.                 else if (String.valueOf(mid).length() < 4) {
  78.                         result = before1 + "亿" + mid1 + "万" + "零" + last1 + "圆整";
  79.                 }
  80.                 // 否则都不添加零
  81.                 else {
  82.                         result = before1 + "亿" + mid1 + "万" + last1 + "圆整";
  83.                 }
  84.                 return result;
  85.         }

  86.         // 可以将不大于四位的数字汉字表达式输出的方法
  87.         public static String change(long num) {
  88.                 // TODO Auto-generated method stub
  89.                 // 将long型转换层字符串型
  90.                 String str = String.valueOf(num);
  91.                 // 定义一个空字符串
  92.                 String result = "";
  93.                 // 定义两个数组用来存放中文数字汉字和单位
  94.                 String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
  95.                 String[] unitArr = { "拾", "佰", "仟" };
  96.                 // 遍历
  97.                 for (int i = 0; i < str.length(); i++) {
  98.                         // 获取每一位的数字
  99.                         int numStr = str.charAt(i) - 48;
  100.                         // 如果不是最后一位数字且不是0则需要添加单位
  101.                         if (i != str.length() - 1 && numStr != 0) {
  102.                                 result += hanArr[numStr] + unitArr[str.length() - 2 - i];
  103.                         }
  104.                         // 如果这个数字为0则输出空
  105.                         else if (num == 0) {
  106.                                 result = "";
  107.                         }
  108.                         // 如果最后一个数字为零
  109.                         else if (i == str.length() - 1 && numStr == 0) {
  110.                                 result += "";
  111.                         }
  112.                         // 否则不添加单位
  113.                         else {
  114.                                 result += hanArr[numStr];
  115.                         }
  116.                 }
  117.                 // 遍历结果合并零
  118.                 if (result.contains("零零")) {
  119.                         result = result.replace("零零", "零");
  120.                 }
  121.                 return result;
  122.         }
  123. }
复制代码
ps:注释很多,所以多了很多行数,已试过各类情况都可以处理,自己慢慢做的,纯手动,虽然长点,但是完全没问题。


作者: 袁志娜    时间: 2016-9-2 23:09
想法都挺不错
作者: YSL450125    时间: 2016-9-21 13:17
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

感觉你这个方法挺好的,我正则学的不太好,当时跟你差不多做法,到正则的时候卡住了,卸载感觉对只是理解的又深了一点,感谢你
作者: 江楠大盗    时间: 2016-9-27 10:15
我手心里的宝 发表于 2013-4-8 09:03
package com.itheima;

/**

你真是太聪明了




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2