疯狂JAVA讲义---第九章（下）：国际化

国际化也称I18N,即InternationalizatioN，中间18个字母。

Java对国际化的支持的非常好，提供了3个类分别是ResourceBundle(用于加载语言包)，Locale(用于封装特定国家语言环境)，MessageFormat(用于格式化带占位符的字符串)。下面举个例子来说明，eg(未国际化)

1. public class RawHello
2. {
3.     public static void main(String[] args)
4.     {
5.         System.out.println("Hello World");
6.     }   
7. }

将上面的代码进行国际化，eg

1. public class Hello
2. {
3.     public static void main(String[] args)
4.     {
5.         //取得系统默认的国家/语言环境
6.         Locale myLocale = Locale.getDefault();
7.         //根据指定国家/语言环境加载资源文件
8.         ResourceBundle bundle = ResourceBundle.getBundle("mess" , myLocale);
9.         //打印从资源文件中取得的消息
10.         System.out.println(bundle.getString("hello"));
11.     }   
12. }

编辑下面两个文件放入默认包中（根目录）

mess_en_US.properites这个名字固定mess就是上面我们调用的名字

1. • hello=Welcome You!

中文汉化的比较麻烦由于是unicode编码，首先要编辑mess_zh_CN.properites

1. hello=你好！

然后在cmd 中利用命令native2ascii mess_zh_CN.properties temp.properties

在当前目录得到temp.properties内容为

1. hello=/u60a8/u597d/uff01

这样就实现了国际化，根据你系统环境的不同改变语言。

然后讲下国际化占位符的使用，eg

1. public class HelloArg
2. {
3.     public static void main(String[] args)
4.     {
5.     Locale currentLocale= Locale.getDefault();
6.         ResourceBundle bundle = ResourceBundle.getBundle("MyResource" , currentLocale);
7.         String msg = bundle.getString("msg");       
8.         System.out.println(MessageFormat.format(msg , "yeeku" , new Date()));
9.     }   
10. }

然后编辑MyResource_en_US.properties为

1. msg=Hello,{0}!Today is {1}.

国际化就这么简单，对于使用IDE的人说更方便，有些IDE可以自动转unicode编码。

下面讲下数字的国际化，我们利用NumberFormat类，eg

1. public class TestNumberFormat
2. {
3.     public static void main(String[] args) 
4.     {
5.         //需要被格式化的数字
6.         double db = 1234000.567;
7.         //创建四个Locale，分别代表中国、日本、德国、美国
8.         Locale[] locales = {Locale.CHINA, Locale.JAPAN, Locale.GERMAN, Locale.US};
9.         NumberFormat[] nf = new NumberFormat[12];
10.         //为上面四个Locale创建12个NumberFormat对象
11.         //每个Locale分别有通用格式器、百分比格式器、货币格式器
12.         for (int i = 0 ; i < locales.length ; i++)
13.         {
14.             nf[i * 3] = NumberFormat.getNumberInstance(locales[i]);
15.             nf[i * 3 + 1] = NumberFormat.getPercentInstance(locales[i]);
16.             nf[i * 3 + 2] = NumberFormat.getCurrencyInstance(locales[i]);
17.         }
18.         for (int i = 0 ; i < locales.length ; i++)
19.         {
20.             switch (i)
21.             {
22.                 case 0:
23.                     System.out.println("-------中国的格式--------");
24.                     break;
25.                 case 1:
26.                     System.out.println("-------日本的格式--------");
27.                     break;  
28.                 case 2:
29.                     System.out.println("-------德国的格式--------");
30.                     break;
31.                 case 3:
32.                     System.out.println("-------美国的格式--------");
33.                     break;                  
34.             }
35.             System.out.println("通用数值格式：" + nf[i * 3].format(db));
36.             System.out.println("百分比数值格式：" + nf[i * 3 + 1].format(db));
37.             System.out.println("货币数值格式：" + nf[i * 3 + 2].format(db));
39.         }
41.     }
42. }

日期的国际化也是件麻烦事，我也说下，一般不是很严格的话，使用SimpleDateFormat类，这个类方便而且人性化，eg

1. public class TestSimpleDateFormat
2. {
3.     public static void main(String[] args) throws Exception
4.     {
5.         Date d = new Date();
6.         //创建一个Simpledate
7.         SimpleDateFormat sdf1 = new SimpleDateFormat("Gyyyy年中第D天");
8.         //将d格式化成日期，输出：公元2007年中第354天
9.         String dateStr = sdf1.format(d);
10.         System.out.println(dateStr);
11.         //一个非常特殊的日期字符串
12.         String str = "07###三月##21";
13.         SimpleDateFormat sdf2 = new SimpleDateFormat("y###MMM##d");
14.         //将日期字符串解析成日期，输出：Wed Mar 21 00:00:00 CST 2007
15.         System.out.println(sdf2.parse(str));
16.     }
17. }

这个类不但可以格式化日期，而且可以解析日期。

如果你要一板一眼的国际化日期，那就用DateFormat类，eg

1. public class TestDateFormat
2. {
3.     public static void main(String[] args) 
4.     {
5.         //需要被格式化的日期
6.         Date dt = new Date();
7.         //创建两个Locale，分别代表中国、美国
8.         Locale[] locales = {Locale.CHINA, Locale.US};
9.         DateFormat[] df = new DateFormat[16];
10.         //为上面两个Locale创建16个DateFormat对象
11.         for (int i = 0 ; i < locales.length ; i++)
12.         {
13.             df[i * 8] = DateFormat.getDateInstance(SHORT, locales[i]);
14.             df[i * 8 + 1] = DateFormat.getDateInstance(MEDIUM, locales[i]);
15.             df[i * 8 + 2] = DateFormat.getDateInstance(LONG, locales[i]);
16.             df[i * 8 + 3] = DateFormat.getDateInstance(FULL, locales[i]);
17.             df[i * 8 + 4] = DateFormat.getTimeInstance(SHORT, locales[i]);
18.             df[i * 8 + 5] = DateFormat.getTimeInstance(MEDIUM , locales[i]);
19.             df[i * 8 + 6] = DateFormat.getTimeInstance(LONG , locales[i]);
20.             df[i * 8 + 7] = DateFormat.getTimeInstance(FULL , locales[i]);
21.         }
22.         for (int i = 0 ; i < locales.length ; i++)
23.         {
24.             switch (i)
25.             {
26.                 case 0:
27.                     System.out.println("-------中国日期格式--------");
28.                     break;
29.                 case 1:
30.                     System.out.println("-------美国日期格式--------");
31.                     break;                      
32.             }
33.             System.out.println("SHORT格式的日期格式：" + df[i * 8].format(dt));
34.             System.out.println("MEDIUM格式的日期格式：" + df[i * 8 + 1].format(dt));
35.             System.out.println("LONG格式的日期格式：" + df[i * 8 + 2].format(dt));
36.             System.out.println("FULL格式的日期格式：" + df[i * 8 + 3].format(dt));
37.             System.out.println("SHORT格式的时间格式：" + df[i * 8 + 4].format(dt));
38.             System.out.println("MEDIUM格式的时间格式：" + df[i * 8 + 5].format(dt));
39.             System.out.println("LONG格式的时间格式：" + df[i * 8 + 6].format(dt));
40.             System.out.println("FULL格式的时间格式：" + df[i * 8 + 7].format(dt));
41.         }
42.     }
43. }