黑马程序员_练习

----------- android培训、java培训、期待与您交流！------------

已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容
并按照自然顺序排序后输出到b.txt文件中
文件内容应为“abcd…………..”这样的顺序。

public class Test1 {
	
	public static void main(String[] args) throws Exception {
		BufferedReader bufr = new BufferedReader(new FileReader("temp\\a.txt"));
		BufferedWriter bufw = new BufferedWriter(new FileWriter("temp\\b.txt"));
		String line = null;
		while((line = bufr.readLine()) != null){
			char[] chs = line.toCharArray();
			Arrays.sort(chs);
			bufw.write(new String(chs));
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
		
	}
}

定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法;?
例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。

public enum Lamp {
	RED("GREEN"), GREEN("YELLOW"), YELLOW("RED");
	
	private String next;

	private Lamp(String next) {
		this.next = next;
	}

	public Lamp nextLamp() {
		return Lamp.valueOf(next);
	}
}

编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

public class Test1 {

	public static void main(String[] args) throws Exception {
		Random random = new Random();
		List<Integer> list = new ArrayList<Integer>();
		int i = 0;
		while(i != 10){
			int j = random.nextInt(20);
			if(!list.contains(j)){
				list.add(j);
				i++;
			}
		}
		System.out.println(list);
	}
}

自定义枚举 Week用于表示星期，Mon,Tue，Wed...要求每个枚举值都有toLocaleString方法

用于获得枚举所表示的星期的中文格式 星期一、星期二、星期三...

public class Test1 {
	
	public static void main(String[] args) {
		Week week = Week.MON;
		System.out.println(week.toLocaleString());
	}
}

// Week枚举类中的MON、TUE等每一个枚举值都代表枚举类的一个静态实例对象
enum Week {

	// 静态的实例的名称最好大写
	MON {// 匿名内部类实现抽象方法
		public String toLocaleString() {
			return "星期一";
		}

	},
	TUE {
		public String toLocaleString() {
			return "星期二";
		}

	},
	WED {
		public String toLocaleString() {
			return "星期三";
		}

	},
	THU {
		public String toLocaleString() {
			return "星期四";
		}

	},
	FRI {
		public String toLocaleString() {
			return "星期五";
		}

	},
	SAT {
		public String toLocaleString() {
			return "星期六";
		}

	},
	SUN {
		public String toLocaleString() {
			return "星期日";
		}

	};

	// 因为星期有很多，每个对象调用此方法返回的结果不确定，所以定义成抽象方法
	public abstract String toLocaleString();
}

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

12  13  14  5 

11  16  15  6 
10  9   8   7 

public class Test1 {
	public static void main(String[] args) {
		/*
		 * 大概思路
		 * 每次的赋值操作可以看成在画一个正方形
		 * 方向是从  左-->右  上-->下  右-->左  下-->上  一共四步
		 * 把打印结果看成大圈套小圈
		 * n=2打印1圈，n=3打印2圈，n=4打印2圈，n=5打印3圈，一共(n+1)/2圈
		 */
		printArr(4);
	}

	// 打印二维数组
	public static void printArr(int num) {
		// 对num进行健壮性判断
		if (num < 0) {
			throw new RuntimeException("请输入正整数");
		}

		// 定义二维数组
		int[][] arr = new int[num][num];
		// 定义二维数组长度
		int len = arr.length;
		// 计算圈数，最外面一圈编号为0
		int count = 0;
		// 初始化数组的第一个数为1
		int init = 1;
		// 先将打印一圈的方式写好，那么打印完这一圈之后就是接着打印里面的一圈，一直打印到最里面一圈，借助递归的思想
		setArray(arr, len, count, init);
		// 遍历已经通过递归赋值完成的二维数组
		printArr2(arr);
	}

	public static void setArray(int[][] arr, int len, int count, int init) {
		// 控制递归条件
		if (len > 0) {
			// 纵坐标的值
			int j = 0;
			// i的范围控制每圈赋值的个数,复制操作相当于在画一个正方形,分4次赋值完一圈,有4个if判断
			for (int i = 0; i < (len - 1) * 4; i++) {
				// 左-->右 赋值
				if (i < len - 1) {
					arr[count + 0][count + i] = init++;
				}
				// 上-->下 赋值
				else if (i < 2 * len - 2) {
					arr[count + j++][arr.length - 1 - count] = init++;
				}
				// 右-->左 赋值
				else if (i < 3 * len - 3) {
					arr[arr.length - 1 - count][(j--) + count] = init++;
				}
				// 下-->上 赋值
				else if (i < 4 * len - 4) {
					arr[arr.length - 1 - (j++) - count][0 + count] = init++;
				}
			}

			// 当n为奇数时，存在n=1的情况，最里圈只有一个数
			if (len == 1) {
				arr[arr.length / 2][arr.length / 2] = init;
			}

			// 增加圈数
			count++;
			// 每次打印完一圈左右两边都多出两个元素，所以每次要进行-2操作
			len -= 2;
			// 递归
			setArray(arr, len, count, init);
		}
	}

	// 遍历二维数组
	private static void printArr2(int[][] arr) {
		// 二维数组的每个元素都是一个一维数组，所以需要双重for循环
		for (int[] ii : arr) {
			// 遍历一维数组
			for (int i : ii) {
				System.out.print(i + "\t");
			}
			// 遍历完每一个一维数组后换行
			System.out.println();
		}
	}

}

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

public class Test10 {

	// 定义字符数组存储中国传统数字形式
	public static final char[] TRADITION = new char[] { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
	// 定义字符数组存储数字的单位
	public static final char[] UNITS = new char[] { '圆', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟', '万' };

	public static void main(String[] args) {
		// 程序只支持到万亿单位
		System.out.println(transform(101000001010L));
	}
	
	// 数字转中国传统格式的方法
	public static String transform(long number) {
		// 如果输入的数字超出万亿，或输入的数字小于0，则抛出异常
		String num = number + "";
		if (num.length() > UNITS.length || number < 0) {
			throw new RuntimeException("输入的数字有误（只支持到万亿单位），请重新输入");
		}

		// 定义一个字符串缓冲区对字符进行存储
		StringBuilder sb = new StringBuilder();
		// 用来记录住存储数字的单位
		int index = 0;
		// 用来记录住数字的最后一位
		long lastNumber = 0;
		
		/*
		 * 大概思路：
		 * 	定义循环，每次把数字对10进行取模，取最后一位数字的中文格式和单位进行组合，添加到字符缓冲区
		 * 	再对数字进行除以10操作，把最后一位去除，进行下次循环
		 * 	需要定义变量存储数字的单位，每循环一次自增一次
		 * 	利用StringBuilder的insert方法每次插入的都是字符串的最前面，所以保证了单位的正确
		 * 	查找数字对应的中文格式和单位均用查表法来找寻对应字符
		 */
		
		while (number != 0) {
			// 通过循环，number对10取模，每次得出的都是number的最后一位
			lastNumber = number % 10;
			
			// 虽然每次取到的都是number的最后一位，但是数字的单位在不断上升，所以进行自增
			sb.insert(0, UNITS[index++]);
			
			// 最后一位的数字是几，就用查表返回此数字的中文表现形式
			sb.insert(0, TRADITION[(int) lastNumber]);
			
			// 除以10操作，把已经记录的最后一位数字去除，进行下次循环
			number /= 10;
		}
		
		/*
		 * 假设输入的数是101 000 001 010
		 * 按照如上算法得出的字符串为"壹仟  零佰  壹拾  零亿   零仟  零佰  零拾  零万  壹仟  零佰  壹拾  零圆" 
		 * 内容很乱，所以需要如下正则进行替换（方便观看所以加的空格，实际没有）
		 * 
		 * 第一次替换为："壹仟  零  壹拾  零亿   零  零  零  零万  壹仟  零  壹拾  零圆" 
		 * 
		 * 第二次替换为："壹仟  零  壹拾  亿   零  零  零  零万  壹仟  零  壹拾  零圆"
		 * 
		 * 第三次替换为："壹仟  零  壹拾  亿   零  壹仟  零  壹拾  零圆"
		 * 
		 * 第四次替换为："壹仟  零  壹拾  亿   零  壹仟  零  壹拾  零圆"
		 * 
		 * 第五次替换为："壹仟  零  壹拾  亿   零  壹仟  零  壹拾  圆"
		 * 
		 * 第六次替换为："壹仟  零  壹拾  亿   零  壹仟  零  壹拾  圆整"
		 */
		
		// 通过正则表达式将字符串的值进行优化，去除多余的字符
		return sb.toString().replaceAll("零[拾佰仟]", "零")
							.replaceAll("零+亿", "亿").replaceAll("零{4}万", "零")
							.replaceAll("零+万", "万").replaceAll("零+圆", "圆")
							.replaceAll("零+", "零") + "整";
	}

}