疯狂JAVA讲义---第四章（下）:数组

第四章的联系基本都是书中例子的加强，由于比较多我就用其作为一天的blog。不知不觉我已经写blog写了半个多月，加油~~~~呵呵

1.实现substring的方法，但要求按字节截取，而不是String的substring按字符截取。

1. public class SubString {
2.     public static String getSubString(String str, int begin, int end) {
3.         byte[] c = str.getBytes();
4.         byte[] c2 = new byte[end - begin + 1];
5.         int j = 0;
6.         for (int i = begin; i < end + 1; i++) {
7.             c2[j] = c[i];
8.             j++;
9.         }
10.        String sub=new String(c2);
11.         return sub;
12.     }
14.     public static void main(String[] args) {
15.         System.out.println(getSubString("中国abc", 2, 4));
16.     }
17. }

这是按字节截取的字符串，由于中文占2个字节，如上例你截取1到4会出现乱码的文字。

2.浮点数人民币读法eg.1006.333

1.     public static String[] divide(double num) {
2.         //将一个浮点数强制类型转换为long，即得到它的整数部分
3.         long zheng = (long) num;
4.         //浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数
5.         long xiao = Math.round((num - zheng) * 100);
6.         //下面用了2种方法把整数转换为字符串
7.         String xiaostr;
8.         if (xiao > 10) {
9.             xiaostr = String.valueOf(xiao);
10.         } else {
11.             xiaostr = "0" + String.valueOf(xiao);
12.         }
13.         return new String[]{zheng + "", xiaostr};
14.     }
16.     private String toHanStr(double inputNum) {
17.         String[] numStrs = divide(inputNum);
18.         String numStr1 = numStrs[0];
19.         String result = "";
20.         int numLen1 = numStr1.length();
21.         int oldNum = -1;
22.         //依次遍历数字字符串的每一位数字
23.         for (int i = 0; i < numLen1; i++) {
24.             //把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
25.             //因此把char型数字减去48得到int型数字，例如'4'被转换成4。
26.             int num = numStr1.charAt(i) - 48;
27.             //如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
28.             if (i != numLen1 - 1 && num != 0) {
29.                 result += hanArr[num] + unitArr[numLen1 - 2 - i];
30.             }
31.             //否则不要添加单位
32.             else {
33.                 if (oldNum == 0) {
34.                     result += hanArr[num];
35.                 }
36.                 oldNum = num;
37.             }
38.         }
39.         result += "元";
40.         String numStr2 = numStrs[1];
41.         int numLen2 = numStr2.length();
42.         for (int i = 0; i < numLen2; i++) {
43.             int num = numStr2.charAt(i) - 48;
44.             if (i != numLen2 && num != 0) {
45.                 result += hanArr[num] + unitArr2[i];
46.             }
47.         }
48.         return result;
49.     }
51.     public static void main(String[] args) {
52.         Num2RmbPlus nr = new Num2RmbPlus();
53.         System.out.println(nr.toHanStr(01006.303));
54.     }
55. }

这题要细心注意各种细节，数字读起来更口语话。

3.编写控制台五子棋

  电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。
                还涉及
                   1.座标的有效性，只能是数字，不能超出棋盘范围
                   2.如果下的棋的点，不能重复下棋。
                   3.每次下棋后，需要扫描谁赢了

1. public class GobangPlus {
2.     //定义一个二维数组来充当棋盘
3.     private String[][] board;
4.     //定义棋盘的大小
5.     private static int BOARD_SIZE = 15;
7.     public void initBoard() {
8.         //初始化棋盘数组
9.         board = new String[BOARD_SIZE][BOARD_SIZE];
10.         //把每个元素赋为"╋"，用于在控制台画出棋盘
11.         for (int i = 0; i < BOARD_SIZE; i++) {
12.             for (int j = 0; j < BOARD_SIZE; j++) {
13.                 board[i][j] = "╋";
14.             }
15.         }
16.     }
18.     //在控制台输出棋盘的方法
19.     public void printBoard() {
20.         //打印每个数组元素
21.         for (int i = 0; i < BOARD_SIZE; i++) {
22.             for (int j = 0; j < BOARD_SIZE; j++) {
23.                 //打印数组元素后不换行
24.                 System.out.print(board[j][i]);
25.             }
26.             //每打印完一行数组元素后输出一个换行符
27.             System.out.print("/n");
28.         }
29.     }
31.     public String checkWin(int x, int y, String color) {
32.         //横
33.         int x1;
34.         int x2;
35.         int y1;
36.         int y2;
37.         if (x - 4 > 0) {
38.             x1 = x - 4;
39.         } else {
40.             x1 = 0;
41.         }
42.         if (x + 4 < 15) {
43.             x2 = x + 4;
44.         } else {
45.             x2 = 14;
46.         }
47.         if (y - 4 > 0) {
48.             y1 = y - 4;
49.         } else {
50.             y1 = 0;
51.         }
52.         if (y + 4 < 15) {
53.             y2 = y + 4;
54.         } else {
55.             y2 = 14;
56.         }
57.         //横
58.         int result = 0;
59.         for (int i = x1; i <= x2; i++) {
60.             if (result != 5) {
61.                 if (i < 0 || i > 15 || y < 0 || y > 15) {
62.                     System.out.println("error");
63.                 }
64.                 if (board[i][y] == color) {
65.                     result++;
66.                 } else {
67.                     result = 0;
68.                 }
69.             } else {
70.                 return color + " Win!!";
71.             }
72.         }
73.           if (result == 5) {
74.               return color + " Win!!";
75.          }
76.         //竖
77.         result = 0;
78.         for (int i = y1; i <= y2; i++) {
79.             if (result != 5) {
80.                 if (x < 0 || x > 15 || i < 0 || i > 15) {
81.                     System.out.println("error");
82.                 }
83.                 if (board[x][i] == color) {
84.                     result++;
85.                 } else {
86.                     result = 0;
87.                 }
88.             } else {
89.                 return color + " Win!!";
90.             }
91.         }
92.           if (result == 5) {
93.               return color + " Win!!";
94.          }
95.         //向左斜
96.         result = 0;
97.         int moveX = 0;
98.         int moveY = 0;
99.         if (x - x1 >= y - y1) {
100.             moveX = y - y1;
101.         } else {
102.             moveX = x - x1;
103.         }
104.         if (x2 - x >= y2 - y) {
105.             moveY = y2 - y;
106.         } else {
107.             moveY = x2 - x;
108.         }
109.         for (int i = -moveX; i <= moveY; i++) {
110.             if (result != 5) {
111.                 if (x + i < 0 || x + i > 15 || y + i < 0 || y + i > 15) {
112.                     System.out.println("error");
113.                 }
114.                 if (board[x + i][y + i] == color) {
115.                     result++;
116.                 } else {
117.                     result = 0;
118.                 }
119.             } else {
120.                 return color + " Win!!";
121.             }
122.         }
123.          if (result == 5) {
124.               return color + " Win!!";
125.          }
127.         //向右斜
128.         result = 0;
129.         int moveX2 = 0;
130.         int moveY2 = 0;
131.         if (x - x1 >= y2 - y) {
132.             moveX2 = y2 - y;
133.         } else {
134.             moveX2 = x - x1;
135.         }
136.         if (x2 - x >= y - y1) {
137.             moveY2 = y - y1;
138.         } else {
139.          moveY2 = x2 - x;
140.         }
141.        for (int i = -moveX2; i <= moveY2; i++) {
142.             if (result != 5) {
143.                 if (x + i < 0 || x + i > 15 || y - i < 0 || y - i > 15) {
144.                     System.out.println("error");
145.                 }
146.                 if (board[x + i][y - i] == color) {
147.                     result++;
148.                 } else {
149.                     result = 0;
150.                 }
151.             } else {
152.                 return color + " Win!!";
153.             }
154.         }
155.          if (result == 5) {
156.               return color + " Win!!";
157.          }
158.         return null;
159.     }
161.     public static void main(String[] args) throws Exception {
162.         GobangPlus gb = new GobangPlus();
163.         gb.initBoard();
164.         gb.printBoard();
165.         System.out.println("请输入您下棋的座标，应以x,y的格式：");
166.         //这是用于获取键盘输入的方法
167.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
168.         String inputStr = null;
169.         //br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br读取到。
170.         while ((inputStr = br.readLine()) != null) {
171.             //将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
172.             String[] posStrArr = inputStr.split(",");
173.             //将2个字符串转换成用户下棋的座标
174.             int xPos = Integer.parseInt(posStrArr[0]);
175.             int yPos = Integer.parseInt(posStrArr[1]);
176.             //把对应的数组元素赋为"●"。
177.             gb.board[xPos - 1][yPos - 1] = "●";
178.             String win = gb.checkWin(xPos - 1, yPos - 1, "●");//每次下棋后，需要扫描谁赢了
179.             if (win != null) {
180.                 gb.printBoard();
181.                 System.out.println(win);
182.                 System.exit(0);
183.             }
186.             int aiX;
187.             int aiY;
188.             while (true) {
189.                 Random r1 = new Random();
190.                 aiX = r1.nextInt(BOARD_SIZE - 1);//座标的有效性，只能是数字，不能超出棋盘范围
191.                 Random r2 = new Random();
192.                 aiY = r2.nextInt(BOARD_SIZE - 1);
193.                 if (gb.board[aiX][aiY] == "╋") { //如果下的棋的点，不能重复下棋。
194.                     gb.board[aiX][aiY] = "○";
195.                     break;
196.                 }
197.             }
198.             win = gb.checkWin(aiX, aiY, "○"); //每次下棋后，需要扫描谁赢了
199.             if (win != null) {
200.                 gb.printBoard();
201.                 System.out.println(win);
202.                 System.exit(0);
203.             }
204.             gb.printBoard();
205.             System.out.println("请输入您下棋的座标，应以x,y的格式：");
206.         }
207.     }
208. }
209. 这道题看看那么简单，我还搞了老半天，主要是由于checkWin中的if (result != 5) 这个条件没注意到一种特殊情况，大家可以去想想，还有什么好方法大家可以交流。