试试，应该行

复习下多线程

求技术分~
另外，可以简单评价下我的答案吗？

Doug 发表于 2015-4-11 12:38
求技术分~
另外，可以简单评价下我的答案吗？

挺好的，算法不错，正则用的也不错。赞一个，可以作为答案参考：

1. /*题目：已知：本地D盘根目录下有2个文本文件a.txt,c.txt文本格式及内容如下图：
   
2. 
   
3. 求：
   
4.         ①将a.txt文件中的所有奇数行（也就是第1、3行）字母跟数字互换
   
5.                 （比如第一行，处理后为：1a 2a 3a 4a），
   
6.                 偶数行顺序倒序排列（比如第二行，处理后为：b4 b3 b2 b1），
   
7.                 然后将结果保存在b.txt中。
   
8.         ②将c.txt中的数字进行如下运算，
   
9.                 第n行m列是第（n-1）行第m列的数字之和
   
10.                 （提示：第一行不变，第二行变为：6 8 10 12，第三行变为：15 18 21 24，第四行变为28 32 36 40），
    
11.                 然后将计算结保存在d.txt中。
    
12.                 */
    
13. 
    
14. package com.itheima.test02;
    
15. 
    
16. import java.io.BufferedReader;
    
17. import java.io.FileReader;
    
18. import java.io.IOException;
    
19. import java.io.PrintWriter;
    
20. import java.util.ArrayList;
    
21. import java.util.List;
    
22. 
    
23. public class Test {
    
24.         public static void main(String[] args) throws IOException {
    
25.                 // ①将a.txt文件中的所有奇数行（也就是第1、3行）字母跟数字互换,
    
26.                 // 偶数行顺序倒序排列（比如第二行，处理后为：b4 b3 b2 b1）,然后将结果保存在b.txt中。
    
27.                 BufferedReader br = new BufferedReader(new FileReader("d:/a.txt"));
    
28.                 PrintWriter pw = new PrintWriter("d:/b.txt");
    
29.                 String line = null;
    
30.                 boolean flag = false;
    
31.                 while ((line = br.readLine()) != null) {
    
32.                         flag = !flag;
    
33.                         if (flag) {
    
34.                                 line = processString_1(line);
    
35.                         } else {
    
36.                                 line = processString_3(line);
    
37.                         }
    
38.                         pw.println(line);
    
39.                         pw.flush();
    
40.                 }
    
41.                 br.close();
    
42. 
    
43.                 // ②将c.txt中的数字进行如下运算：n行m列的值为c.txt中（1~n-1）行m列的值之和。
    
44.                 /*
    
45.                  * 思路：每行都分割成数组，并添加到List中。List的长度就是行数。
    
46.                  * 新的List的当前行当前列等于旧的List的当前行当前列和新的List的上一行当前列之和。
    
47.                  */
    
48.                 BufferedReader br2 = new BufferedReader(new FileReader("d:/c.txt"));
    
49.                 PrintWriter pw2 = new PrintWriter("d:/d.txt");
    
50.                 String line2 = null;
    
51.                 List<String[]> srcList = new ArrayList<String[]>();
    
52.                 List<String[]> desList = new ArrayList<String[]>();
    
53.                 while ((line = br2.readLine()) != null) {
    
54.                         String[] arr = line.split(" +");
    
55.                         srcList.add(arr);
    
56.                         // 写入d.txt
    
57.                         if (srcList.size() == 1) {
    
58.                                 desList.add(arr);
    
59.                                 // pw2.print(line2);
    
60.                                 // pw2.flush();
    
61.                         } else {
    
62.                                 func(srcList, desList);
    
63.                         }
    
64.                         // 将desList当前行写成字符串并输出。
    
65.                         String out = arrayToString(desList.get(desList.size() - 1));
    
66.                         pw2.println(out);
    
67.                         pw2.flush();
    
68.                 }
    
69.                 br2.close();
    
70.                 pw2.close();
    
71.         }
    
72. 
    
73.         public static String arrayToString(String[] array) {
    
74.                 StringBuilder sb = new StringBuilder();
    
75.                 for (String str : array) {
    
76.                         sb.append(str + " ");
    
77.                 }
    
78.                 return new String(sb);
    
79.         }
    
80. 
    
81.         /**
    
82.          * 新的List的当前行当前列等于旧的List的当前行当前列和新的List的上一行当前列之和。
    
83.          *
    
84.          * @param srcList
    
85.          *            源List。
    
86.          * @param desList
    
87.          *            新List。
    
88.          */
    
89.         public static void func(List<String[]> srcList, List<String[]> desList) {
    
90.                 int len = srcList.size();
    
91.                 String[] srcArr = srcList.get(len - 1);// 旧的List的当前行
    
92.                 String[] desArr = desList.get(len - 2);// 新的List的上一行
    
93.                 String[] newArr = new String[srcArr.length];
    
94.                 for (int index = 0; index < srcArr.length; index++) {
    
95.                         int value = Integer.valueOf(srcArr[index]) + Integer.valueOf(desArr[index]);
    
96.                         newArr[index] = "" + value;
    
97.                 }
    
98.                 desList.add(newArr);
    
99.         }
    
100. 
     
101.         /**
     
102.          * 将原字符串中的相邻的字母和数字（字母在前数字在后）位置互换。
     
103.          *
     
104.          * @param str
     
105.          *            给定的字符串。
     
106.          * @return 返回修改后的字符串。
     
107.          */
     
108.         public static String processString_1(String str) {
     
109.                 String regex = "(\\w)(\\d)";
     
110.                 return str.replaceAll(regex, "$2$1");
     
111.         }
     
112. 
     
113.         /**
     
114.          * 将原字符串中的相邻的数字和字母（数字在前字母在后）位置互换。
     
115.          *
     
116.          * @param str
     
117.          *            给定的字符串。
     
118.          * @return 返回修改后的字符串。
     
119.          */
     
120.         public static String processString_2(String str) {
     
121.                 String regex = "(\\d)(\\w)";
     
122.                 return str.replaceAll(regex, "$2$1");
     
123.         }
     
124. 
     
125.         /**
     
126.          * 将源字符串逆序，但源字符串中相邻的字母和数字相对位置不改变。
     
127.          *
     
128.          * @param str
     
129.          *            给定的字符串。
     
130.          * @return 返回修改后的字符串。
     
131.          */
     
132.         public static String processString_3(String str) {
     
133.                 return processString_2(reverseString(str).trim());
     
134.         }
     
135. 
     
136.         /**
     
137.          * 将源字符串逆序。
     
138.          *
     
139.          * @param str
     
140.          *            给定的字符串。
     
141.          * @return 返回修改后的字符串。
     
142.          */
     
143.         public static String reverseString(String str) {
     
144.                 StringBuilder sb = new StringBuilder();
     
145.                 for (int index = 0; index < str.length(); index++) {
     
146.                         sb.append(str.charAt(str.length() - 1 - index));
     
147.                 }
     
148.                 return new String(sb);
     
149.         }
     
150. }
     

复制代码

王震阳老师 发表于 2015-4-11 13:32
挺好的，算法不错，正则用的也不错。赞一个，可以作为答案参考：

谢谢王sir~

练手了

拿题试试看

回帖领题

回帖领题

答题拿分。。

:handshake

阳哥来看看:handshake

看题看题

提交答案，txt文档是UTF-8;

把文件放在根目录下了，读取的位置也是根目录的。没看到d盘。。。。

来那题。。。。。。。

暗月麟血 发表于 2015-4-22 16:51
来那题。。。。。。。

test30.zip (2.4 KB, 下载次数: 0)

2015-4-23 09:36 上传

点击文件名下载附件
阅读权限: 200

领题~·~

答题答题

回帖领题~