黑马入学考试题

发表于   |   分类于   |     |   阅读次数

20160619
通过题目也可以学习很多。
不断总结，不断提升，刷新自己的知识库。

方法中的内部类能不能访问方法中的局部变量，为什么？

Java中的内部类分四种：成员内部类、局部内部类、静态内部类和匿名内部类。

局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。

注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。

先看一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Test1 {
	private int s = 100;
	private int out_i = 1;

	public void f(final int k) {
		final int s = 200;
		int i = 1;
		final int j = 10;
		
		class Inner {		// 定义在方法内部
			int s = 300;	// 可以定义与外部类同名的变量
			int inner_i = 100;
			//static int m = 20;						//不可以定义静态变量
			
			Inner(int k) {
				inner_f(k);
			}
			
			void inner_f(int k) {
				System.out.println(out_i);			// 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
				System.out.println(k);				// *****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****
				//System.out.println(i);
				System.out.println(s);				// 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
				System.out.println(this.s);			// 用"this.变量名" 访问的也是内部类变量
				System.out.println(this.s);			// 用外部"外部类类名.this.变量名"访问的是外部类变量
			}
		}
		new Inner(k);
	}

	public static void main(String[] args) {
		Test1 out = new Test1();					// 访问局部内部类必须先有外部类对象
		out.f(3);
	}
}

注意：

在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。
要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。
通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

综上所述，再重新看待这道题：

所谓“局部内部类”就是在对象的方法成员内部定义的类。

而方法中的类，访问同一个方法中的局部变量，是天经地义的。(即方法中的内部类能访问方法中的局部变量，然而还有一个条件那就是方法中的局部变量得被final修饰)

那么为什么要加final的局部变量才可以被访问呢？

从生命周期的角度看：

内部类的生命周期和方法中的局部变量是不一样的，内部类是也是一个类，是存储在堆中，也只有当对该类的引用消失时，内部类才会消亡。

而方法的局部变量是存储在栈中的，当调用结束时就会退栈，即在内存中这个属性就消失了。
也就是说，内部类的生命周期超过了方法中局部变量的生命周期，内部类可能会调用到已经消失的属性，因此内部类不能访问方法中的局部变量。

那么为什么要加final的局部变量才可以被访问呢？

通过将生成的class文件反编译可以知道：如果局部变量的值在编译期间就可以确定，则直接在局部内部类里面创建一个拷贝。

如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。

那么新的问题来了，在方法中的内部类访问到的方法中的变量和实际方法中的变量是不是同一个变量？

对，会造成数据不一致性，这样就达不到原本的意图和要求。

为了解决这个问题，java编译器就限定必须将方法中的变量设置为final变量，不允许对此变量进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

归纳上述回答的真正核心是：局部内部类对象中包含有要访问的final型局部变量的一个拷贝，成为它的数据成员。

因此，正是在这个意义上，final型局部变量的生命期，超过其方法的一次调用。

严格来说，方法调用结束，所有的局部变量（含final）全死亡了。

但局部内部类对象中有final型局部变量的拷贝。(由于该变量由final修饰，所以一致性的问题也被解决了）

ArrayList list = new ArrayList(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。

编译器编译带参数类型说明的集合时会去去除掉“类型”信息，使程序运行不受影响。

对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。

由于编译生成的字节码会去掉泛型的类型信息，因此只要能跳过编译器，就可以往某个泛型集合中加入其他类型的数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test2 {
	public static void main(String[] args) throws Exception {
		//建立一个String对象
		String str = new String("Hello HeiMa!");
		//建立一个ArrayList<Integer>对象
		ArrayList<Integer> list = new ArrayList<Integer>();
		//通过list类对象获取add(Object e)方法
		Method m = list.getClass().getMethod("add", Object.class);
		//让list调用反射的add方法添加一个String对象即str
		m.invoke(list, str);
		//打印输出
		System.out.println(list.get(0));
	}
}

请说明Java中字符’\’的含义，有什么作用？

在Java中反斜杠’\’代表的是转义字符。

转义字符：通过’\’来转变后面字母或符号的含义。

它用于描述一些无法用单个字符描述的特殊符号，如换行符，退格符，制表符等等（他们在window中分别是\n,\b,\t）。

当遇到一些java语法中被占用的特殊字符的时候，要想原样的输出，就需要在这些特殊的字符前面加入反斜杠。

比如反斜杠本身,单引号,双引号,小括号等，因为语法已经占用，所以要想原样的输出，只有在前面在加一个反斜杠。

这点在读取windows中文件的字符串路径时体现的特别明显，要想路径有效就要在单个反斜杠前在加一个反斜杠用于转义。

常用转义字符：

1
2
3
4
5
6
7
\b：退格
\n：换行
\t：制表符，相当于tab键
\r：回车
\\：表示反斜杠
\'：表示单引号 
\"：表示双引号

API上如下描述：

反斜线字符 (‘\’) 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \ 与单个反斜线匹配，而 { 与左括号匹配。

假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/**
 * 员工类
 * @author WuPeng
 *
 */
abstract class Employee {
	private String name;		//姓名
	private String id;		//工号
	private double salary;		//工资
	
	public Employee(String name, String id, double salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
	
	public Employee(){}
	
	@Override
	public String toString() {
		return "@"+getClass().getName()+":name="+name+",id="+id+",salary="+salary;
	}
	
	abstract void work();

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}
}

/**
 * 经理类
 * @author WuPeng
 *
 */
class Manager extends Employee {
	private double bonus;		//奖金
	
	public Manager(String name, String id, double salary, double bonus) {
		super(name,id,salary);
		this.bonus = bonus;
	}
	
	public Manager(){};
	
	@Override
	void work() {
		System.out.println("Manager work!");
	}
	
	@Override
	public String toString() {
		return "@"+getClass().getName()+"="+getName()+",id="+getId()+",salary"+getSalary()+",bonus="+getBonus();
	}

	public double getBonus() {
		return bonus;
	}

	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
}

/**
 * 4、假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
 * 请使用继承的思想设计出员工类和经理类。
 * 要求类中提供必要的方法进行属性访问。
 * @author WuPeng
 *
 */
public class Test4 {
	public static void main(String[] args) {
		//创建一个员工的匿名内部类
		Employee e = new Employee("关羽","001",1000d) {
			public void work() {
				System.out.println("Employee work!");
			}
		};
		Manager m = new Manager("刘备","002",1200d,100d);
		System.out.println(e.toString());
		e.work();
		System.out.println(m.toString());
		m.work();
	}
}

定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)。

汉字在国标码中的存储为1个字为2个字节。
用普通方法会出现乱码问题
解决办法：ByteArrayOutputStream：可以捕获内存缓冲区的数据，转换成字节数组。
此类实现了一个输出流，其中的数据被写入一个 byte 数组。
缓冲区会随着数据的不断写入而自动增长。
可使用 toByteArray()和 toString()获取数据。
关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何IOException。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Test5 {
	public static void main(String[] args){
		BufferedInputStream bis = null;	//创建带缓冲区的输入流，提高效率
		ByteArrayOutputStream baos = null;
		byte b[] = new byte[5];		//创建大小为5的byte数组
		int num = 0;
		try {
			bis = new BufferedInputStream(new FileInputStream("exercise.txt"));
			baos = new ByteArrayOutputStream();
			while((num=bis.read(b))!=-1){	//调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来
				baos.write(b, 0, num);
			}
			System.out.println(baos.toString("utf8"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
				try {
					if(bis != null)
						bis.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				try {
					if(baos != null)
						baos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
}

把以下IP存入一个txt文件，编写程序把这些IP按数值大小，从小到大排序并打印出来。

  • 61.54.231.245
  • 61.54.231.9
  • 61.54.231.246
  • 61.54.231.48
  • 61.53.231.249
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public class Test6 {
	/**
	 * 获取ip数值
	 * @param ip
	 * @return
	 */
	public static int getNum(String ip){
			String[] s = ip.split("\\.");
			int sum = 0;
			for (int i = 0; i < s.length; i++) {
					sum = sum*256+Integer.parseInt(s[i]);
			}
			return sum;
	}
	
	public static void main(String[] args) {
			BufferedWriter bw = null;	//创建带缓冲区的字符输入流，提高效率
			BufferedReader br = null;	//创建带缓冲区的字符输出流
			try {
				//将ip存入ip.txt
				bw = new BufferedWriter(new FileWriter("ip.txt"));
				bw.write("61.54.231.245");
				bw.newLine();
				bw.write("61.54.231.9");
				bw.newLine();
				bw.write("61.54.231.246");
				bw.newLine();
				bw.write("61.54.231.48");
				bw.newLine();
				bw.write("61.53.231.249");
				bw.flush();

				//从ip.txt中读取数据并存入ArrayList
				br = new BufferedReader(new FileReader("ip.txt"));
				ArrayList<String> list = new ArrayList<String>();
				String str = null;
				while ((str=br.readLine())!=null) {
					list.add(str);
				}
				System.out.println("原始数据：");
				for (String s : list) {
					System.out.println(s);
				}
				//冒泡排序
				for (int i = 0; i < list.size()-1; i++) {
						for (int j = 0; i + j < list.size()-1; j++) {
								String ip1 = list.get(j);
								String ip2 = list.get(j+1);
								if(Test6.getNum(ip1) > Test6.getNum(ip2)) {
									list.set(j, ip2);
									list.set(j+1, ip1);	                            	
								}
						}
				}
				System.out.println("排序后数据：");
				for (String s : list) {
						System.out.println(s);
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				try {
					if(bw!=null)
						bw.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				try {
					if(br!=null)
						br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
	}
}

写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：

1   2   3   4
12  13  14  5
11  16  15  6
10  9   8   7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Test7 {
	static void fun(int a[][],int n){
		int i,j,k=0,m;
		
		if(n % 2 == 0)				//m=⌈n/2⌉
			m = n/2;
		else
			m = n/2 + 1;
		
		for(i=0; i<m; i++) {
			for(j=i; j<n-i; j++) {		//产生该圈上横行的数字
				k++;
				a[i][j] = k;
			}
			for(j=i+1; j<n-i; j++) {	//产生该圈右竖行的数字
				k++;
				a[j][n-i-1] = k;
			}
			for(j=n-i-2; j>=i; j--) {	//产生该圈下横行的数字产生该圈的左竖行的数字
				k++;
				a[n-i-1][j] = k;
			}
			for(j=n-i-2; j>=i+1; j--) {	//产生该圈的左竖行的数字
				k++;
				a[j][i] = k;
			}
		}
		
		//打印输出
		System.out.println(n+"阶螺旋方阵如下：");
		for(i=0; i<n; i++){
			for(j=0; j<n; j++)
				System.out.printf("%-3d ",a[i][j]);
			System.out.println();
		}
	}
	public static void main(String[] args) {
		int n = 4;
		fun(new int[n][n], n);
	}
}

编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。提示：十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，直到被除数为0为止。其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public class Test8 {
	/**
	 * 将一个十进制整数转换为二进制整数
	 * @param decimal
	 * @return
	 */
	public static String toBinary(Integer decimal) {
		boolean negtive = false;			//负数标志，初始化为假
		if(decimal < 0) {				//如果该数是负数，将其变为正数进行后续操作，并置负数标志为真
			/*由于边界问题，-2147483648~-2147483647，所以不能这么做！*/
			//decimal = -decimal;
			negtive = true;
		}
		StringBuffer sb = new StringBuffer();		//创建一个StringBuffer用来存放余数
		Integer n = 0;
		while (decimal != 0) {
			/*  由于边界问题，-2147483648~2147483647，所以采用以下解决办法:
			 *  如果为负数，将得到的余数加绝对值。
			 *  由于Math.abs(int a)的实现如下
			 *  return (a < 0) ? -a : a;
			 *  即CPU会进行一次比较和赋值运算，为了降低时间复杂度采用如下方案。
			 */
			if(negtive)
				n = -decimal % 2;
			n = decimal % 2;
			decimal = decimal / 2;
			sb.append(n);
		}
		if(negtive)					//如果为负数，将StringBuffer末尾添加负号
			sb.append("-");
		sb.reverse();					//将StringBuffer反转得到二进制数对应的StringBuffer类型
		return new String(sb);				//根据StringBuffer创建String对象并返回
	}
	
	/**
	 * 通过键盘输入的字符获取字符串，以回车键结束
	 * @return
	 */
	public static String getString() {
		Scanner s = new Scanner(System.in);		//通过Scanner对象读取键盘输入数据
		return s.nextLine();
	}
	
	/**
	 * 通过正则表达式判断String是否可以表示整数
	 * @param str
	 * @return
	 */
	public static boolean isNumber(String str) {
		return str.matches("^-?\\d+$");
	}
	
	/**
	 * Main方法，程序的入口
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) {
		System.out.print("请输入一个十进制整数：");
		
		String str = getString();
		if(!Test8.isNumber(str)) {
			//整数包括负整数，负号不属于数字字符，所以此处不能提示输入包含非数字字符。
			System.out.println("您输入的整数不正确！");
			System.exit(0);
		}
		try {
			Integer decimal = new Integer(str);
			System.out.println(str + " 的二进制格式为：" + Test8.toBinary(decimal));
		} catch(NumberFormatException e) {
			System.out.println("您输入的整数超过了Integer的范围(-2147483648~2147483647)！");
		}
	}
}

28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）

由题设3个瓶盖可以换一瓶可乐知即3瓶可以换1瓶。

解：设需要买x瓶可乐够28人喝。
    x/3 + x = 28
    (4/3)x = 28
      x = 28*3/4
      x = 21(瓶）
答：要买21瓶可乐够28人喝。

解：设需要买x瓶可乐够50人喝。
    x/3 + x = 50
    (4/3)x = 50
      x = 50*3/4
      x = 37(瓶）...2(瓶盖)
答：买37瓶的时候还差2个瓶盖才够50人喝，所以需要买38瓶。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Test9 {
	/**
	 * n代表人数
	 * @param n
	 * @return 需要购买的可乐数
	 */
	public static int fun(int n){
		//是3的整数倍,不能全部兑换,只能兑换n/3-1瓶
		if(n%3 == 0) {
			return n-(n/3-1);
		}
		
		/* 
		 * 不是3的整数倍,只能兑换floor(n/3)瓶
		 * ps:由于向下取整符号有点难输，所以采用floor代替
		 * 因为被除数和除数都为int类型所以返回int的向下取整		 * 
		 */
		else {
			return n-(n/3);
		}
	}
	
	public static void main(String[] args) {
		System.out.println("需要买"+fun(50)+"瓶可乐");
	}
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
public class Test10 {
	//num寸放基本数字对应汉字
	private final static char[] num = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
	//lv1对应十/百/千
	private final static char[] lv1 = { '拾', '佰', '仟' };
	//lv2对应万/亿/万亿
	private final static String[] lv2 = { "万", "億", "万億"};

	/**
	 * 功能：从键盘读取一行字符串
	 * 
	 * @return
	 */
	static String getString() {
		return new Scanner(System.in).nextLine();
	}

	/**
	 * 功能：判断一个字符串是否为可以表示人民币的数字
	 * 
	 * @param str
	 * @return 如果是返回true,否则返回false
	 */
	static boolean isMoneyNumber(String str) {
		//以1-9开头中间出现0或多个数字末尾出现0或1次.xx(x代表0-9)
		return str.matches("^[1-9]\\d*(\\.\\d{2})?$");
	}

	/**
	 * 功能：将一个阿拉伯数字表示的货币字符串转换成汉字表示的货币字符串
	 * 
	 * @param str
	 * @return
	 * @throws Exception
	 */
	static String transferToChineseMoney(String str) throws Exception {
		/*
		 * 100		-> 壹佰元整 
		 * 100.00	-> 一百元整 
		 * 3 		-> 叁元整
		 * 12.10 	-> 十二元壹角零分 
		 * 23.04 	-> 贰拾叁元零角肆分
		 * 据此，需要考虑到角和分的处理。
		 */
		
		String headStr = null;	// 小数点前面部分
		String endStr = null;	// 小数点后面部分
		
		//单独处理以0开头的数据
		if(str.startsWith("0")) {
			//符合0.xx(x代表0-9)
			if(str.matches("^[0](\\.\\d{2})?$")) {
				if(str.contains(".")) {
					endStr = str.split("\\.")[1];
					//0.00
					if(endStr.equals("00")) {
						return "零圆";
					}
					return "零圆" + handleEnd(endStr);
				} else {
					return "零圆";
				}
			}
			else
				throw new Exception("输入数据有误，请输入能表示货币的阿拉伯数字！");
		}
		
		if (!Test10.isMoneyNumber(str)) {
			throw new Exception("输入数据有误，请输入能表示货币的阿拉伯数字！");
		}
		
		if (str.contains(".")) {
			String[] ss = str.split("\\.");
			headStr = ss[0];
			endStr = ss[1];
		} else {
			headStr = str;
		}

		/*
		 * 金额达到10000000000000000（1兆）以上,向外抛出运行异常
		 */
		if (headStr.length() >= 16) {
			throw new RuntimeException("您输入的金额已经达到1兆以上了，天啊，您确定输入正确么？！");
		}

		String head = handleHead(headStr);
		String end = handleEnd(endStr);

		return head + end;
	}

	/**
	 * 处理xx圆
	 * 
	 * @param head
	 * @return
	 */
	private static String handleHead(String headStr) {
		StringBuffer sb = new StringBuffer();
		char[] headArray = headStr.toCharArray();
		boolean preZero = false;	//判断前一位是否的0
		int zeroCount = 0;			//判断前面相邻的有几个0
		/*循环从左到右处理每个数字*/
		for (int i = 0; i < headArray.length; i++) {
			//拾、佰、仟
			int lv1Index = (headArray.length-1 - i) % 4;
			//万、億
			int lv2Index = (headArray.length-1 - i) / 4;
			
			/* 当前位为0，则使得preZero置为真，zeroCount++，
			 * 需要处理'万'和'億'（因为没有零万、零亿）
			 */
			if (headArray[i] == '0'){	
				preZero = true;
				zeroCount++;
				/* 处理'万'和'億'：当前位处于万位或亿位（lv1Index == 0 && lv2Index > 0）
				 * 且前面的相邻的零小于4位输出该位的'万'或'億'或‘万億’
				 * 如果超过4位，则不需要输出
				 * 例如：100000010壹億零拾，在万位时发现zeroCount=4[万位为0，前面3个0，共4个零]即万位到亿位上都没有数字则万为不输出，
				 * 亿也是同理，它们都是逢4位相间出现一次）
				 */
				if (lv1Index == 0 && lv2Index > 0 && zeroCount < 4){
					sb.append(lv2[ lv2Index-1 ]);
					preZero = false;
				}				
			}
			
			/* 
			 * 当前位不为0，则使得preCount置为0
			 * 如果前一个数为0，则输出[零 + XXX]
			 * 如果当前位处于十百千（十/百/千/十万/百万/千万...），则输出[XXX + 拾/佰/仟]
			 * 如果当前位处于万亿（万/亿/万亿...），则输出[XXX + 万/億]
			 */
			else {
				zeroCount = 0;
				if (preZero){
					sb.append(num[0]);
					preZero = false;
				}
				
				sb.append(num[Integer.parseInt(headArray[i]+"")]);
				if (lv1Index > 0){
					sb.append(lv1[Integer.parseInt((lv1Index-1)+"")]);
				}
				if (lv1Index == 0 && lv2Index >0){
					sb.append(lv2 [Integer.parseInt((lv2Index-1)+"")]);		
				}
			}
		}
		//末尾添加人民币单位'圆'
		sb.append('圆');
		
		return sb.toString();
	}

	/**
	 * 处理xx角xx分的问题
	 * 
	 * @param endStr
	 * @return
	 */
	private static String handleEnd(String endStr) {
		StringBuffer sb = new StringBuffer();
		if(endStr == null)
			sb.append("整");
		else {
			if (endStr.equals("00") ) {
				sb.append("整");
			} else {
				sb.append(num[Integer.parseInt(endStr.charAt(0) + "")] + "角"
						+ num[Integer.parseInt(endStr.charAt(1) + "")] + "分");
			}
		}
			
		return sb.toString();
	}

	public static void main(String[] args) {
		System.out.print("请输入能表示货币的阿拉伯数字（1兆以内，如果有小数请保留2位）:");
		String str = Test10.getString();
		try {
			System.out.println(str + " 对应的汉字货币格式为："
					+ Test10.transferToChineseMoney(str));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
坚持原创技术分享，您的支持将鼓励我继续创作