130242014048-谢添华-第3次实验

Posted 2020-10-15 Xth8013

一、实验目的

1．理解不同体系结构风格的具体内涵。

2．学习体系结构风格的具体实践。

二、实验环境

硬件： win7

软件：Java

三、实验内

“上下文关键字”KWIC(Key Word in Context，文本中的关键字）检索系统接受有序的行集合：每一行是单词的有序集合；每一个单词又是字母的有序集合。通过重复地删除航中第一个单词，并把它插入行尾，每一行可以被“循环地移动”。KWIC检索系统以字母表的顺序输出一个所有行循环移动的列表。

尝试用不同的策略实现这个系统。选择2-3种体系结构风格来实现。

四、实验步骤：

     要求写具体实现代码，并根据实际程序，画出程序的总体体系结构图和算法结构图，以及运行结果截图。

例如，采用主/子程序的风格

1、体系结构图：

 

2、简述体系结构各部件的主要功能，实现思想。

    例如：

上述的主程序/子程序的方法，将问题分解为输入（Input）、移动(Shift)、按字母表排序(sort)、去重(distinct)、输出(Output)。

Input: 将读取到的每行的数据保存到ArrayList<String>定义的rawStrlist中

shift:主函数调用该方法,该方法对rawStrlist中的每行的数据进行循环移位，并将移位得到的新行保存到新的list中

sort:主函数调用该方法, 对list中得到的行数据进行按字母顺序排序,放在orderedList中

distinct:主函数调用该方法,对orderedList进行去重。得到distinctList

Output:主程序调用output方法，将distinctList存储到文本中

3、写出主要的代码

 1 package edu.fjnu.xth8013.mainsub;
 2 
 3 import java.util.List;
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7 
 8         List<String> rawStrlist = null;
 9         List<String> list = null;
10         List<String> orderedList = null;
11         List<String> distinctList = null;
12 
13         // 读取文件，作为输入
14         rawStrlist = FileUtils.loadFileContent("D://KWIC_raw.txt");
15         // 循环移动
16         list = KWIC.shift(rawStrlist);
17         // 排序
18         orderedList = KWIC.sort(list);
19         // 去重
20         distinctList = KWIC.distinct(orderedList);
21         // 输出
22         FileUtils.overwrite("D://KWIC_output.txt", distinctList);
23 
24         // 显示
25         System.out.println("================输入===================");
26         for (String string : rawStrlist) {
27             System.out.println(string);
28         }
29         System.out.println("================循环移动===================");
30         for (String string : list) {
31             System.out.println(string);
32         }
33         System.out.println("================排序===================");
34         for (String string : orderedList) {
35             System.out.println(string);
36         }
37         System.out.println("================去重===================");
38         for (String string : distinctList) {
39             System.out.println(string);
40         }
41 
42     }
43 
44 }

 1 package edu.fjnu.xth8013.mainsub;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.HashMap;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 public class KWIC {
10 
11     /**
12      * 单行循环移动
13      * 
14      * @param str
15      * @return
16      */
17     public static List<String> shift(String str) {
18         List<String> strList = new ArrayList<String>();
19 
20         if (str == null || str.length() <= 0) {
21             return strList;
22         }
23 
24         int idx = -1;
25         int lastIdx = -1;
26         strList.add(str);
27         while ((idx = str.indexOf(\' \', lastIdx + 1)) >= 0) {
28             lastIdx = idx;
29             strList.add(str.substring(idx + 1) + " " + str.substring(0, idx));
30         }
31 
32         return strList;
33     }
34 
35     /**
36      * 多行循环移动
37      * 
38      * @param strList
39      * @return
40      */
41     public static List<String> shift(List<String> strList) {
42         List<String> resultList = new ArrayList<String>();
43         List<String> tempList = new ArrayList<String>();
44 
45         for (String string : strList) {
46             if ((tempList = shift(string)) != null) {
47                 resultList.addAll(tempList);
48             }
49         }
50 
51         return resultList;
52     }
53 
54     /**
55      * 循环排序
56      * 
57      * @param list
58      * @return
59      */
60     public static List<String> sort(final List<String> list) {
61         if (list == null || list.size() <= 0) {
62             return list;
63         }
64 
65         List<String> strList = new ArrayList<String>();
66         strList.addAll(list);
67         Collections.sort(strList);
68 
69         return strList;
70     }
71 
72     /**
73      * 去重
74      * 
75      * @param list
76      * @return
77      */
78     public static List<String> distinct(final List<String> list) {
79         if (list == null || list.size() <= 0) {
80             return list;
81         }
82         List<String> resultList = new ArrayList<String>();
83         Map<String, String> map = new HashMap<String, String>();
84         for (String str : list) {
85             if (str == null || str.length() <= 0) {
86                 continue;
87             }
88             String key = str.substring(0, 1);
89             if (!map.containsKey(key)) {
90                 map.put(str.substring(0, 1), str);
91                 resultList.add(str);
92             }
93         }
94 
95         return resultList;
96     }
97 }

  1 /**
  2  * 
  3  */
  4 package edu.fjnu.xth8013.mainsub;
  5 
  6 import java.io.BufferedReader;
  7 import java.io.File;
  8 import java.io.FileInputStream;
  9 import java.io.FileNotFoundException;
 10 import java.io.FileOutputStream;
 11 import java.io.IOException;
 12 import java.io.InputStreamReader;
 13 import java.io.PrintWriter;
 14 import java.util.ArrayList;
 15 import java.util.List;
 16 
 17 /**
 18  * 
 19  * @Description:
 20  * @author: Xth
 21  * @Date: 2016年8月1日 下午3:22:20
 22  * 
 23  */
 24 public class FileUtils {
 25 
 26     /**
 27      * 读取文本内容（一行为一个字符串）
 28      * 
 29      * @param filePath
 30      * @return
 31      */
 32     public static ArrayList<String> loadFileContent(String filePath) {
 33 
 34         BufferedReader reader = null;
 35         ArrayList<String> stringList = new ArrayList<String>();
 36         String line = null;
 37 
 38         try {
 39             // 根据文件路径创建缓冲输入流
 40             reader = createBufferedReader(filePath);
 41             // 循环读取文件的每一行, 放入字符串数组对象中
 42             while ((line = reader.readLine()) != null) {
 43                 stringList.add(line);
 44             }
 45         } catch (IOException e) {
 46             e.printStackTrace();
 47         } finally {
 48             // 关闭流
 49             closeBufferedReader(reader);
 50         }
 51 
 52         return stringList;
 53     }
 54 
 55     /**
 56      * 将内容回写到文件中
 57      * 
 58      * @param filePath
 59      * @param content
 60      * @param append
 61      *            if true, then bytes will be written to the end of the file
 62      *            rather than the beginning
 63      */
 64     private static void write(String filePath, String content, boolean append) {
 65 
 66         PrintWriter writer = null;
 67 
 68         try {
 69             // 根据文件路径创建缓冲输出流
 70             writer = createPrintWriter(filePath, append);
 71             // 将内容写入文件中
 72             writer.println(content);
 73 
 74         } finally {
 75             // 关闭流
 76             closePrintWriter(writer);
 77         }
 78     }
 79 
 80     /**
 81      * 将内容回写到文件中(覆盖原本内容)
 82      * 
 83      * @param filePath
 84      * @param content
 85      */
 86     public static void overwrite(String filePath, String content) {
 87         write(filePath, content, false);
 88     }
 89 
 90     /**
 91      * 将内容追加到文件中
 92      * 
 93      * @param filePath
 94      * @param content
 95      */
 96     public static void addToWrite(String filePath, String content) {
 97         write(filePath, content, true);
 98     }
 99 
100     /**
101      * 根据文件路径创建缓冲输入流
102      * 
103      * @param filePath
104      * @return
105      */
106     public static BufferedReader createBufferedReader(String filePath) {
107 
108         BufferedReader reader = null;
109 
110         // 根据文件路径创建缓冲输入流
111         try {
112             reader = new BufferedReader(new InputStreamReader(
113                     new FileInputStream(filePath)));
114         } catch (FileNotFoundException e) {
115             e.printStackTrace();
116         }
117 
118         return reader;
119 
120     }
121 
122     /**
123      * 根据文件路径创建缓冲输出流
124      * 
125      * @param filePath
126      * @param append
127      *            if true, then bytes will be written to the end of the file
128      *            rather than the beginning
129      * @return
130      */
131     public static PrintWriter createPrintWriter(String filePath, boolean append) {
132 
133         PrintWriter writer = null;
134 
135         // 根据文件路径创建缓冲输出流
136         try {
137             writer = new PrintWriter(new FileOutputStream(filePath, append));
138         } catch (FileNotFoundException e) {
139             e.printStackTrace();
140         }
141 
142         return writer;
143 
144     }
145 
146     /**
147      * 关闭流
148      * 
149      * @param reader
150      */
151     public static void closeBufferedReader(BufferedReader reader) {
152 
153         if (reader != null) {
154             try {
155                 reader.close();
156             } catch (IOException e) {
157                 reader = null;
158             }
159         }
160     }
161 
162     /**
163      * 关闭流
164      * 
165      * @param writer
166      */
167     public static void closePrintWriter(PrintWriter writer) {
168 
169         if (writer != null) {
170             writer.flush();
171             writer.close();
172         }
173     }
174 
175     /**
176      * 判断一个目标文件是否存在
177      * 
178      * @param filePath
179      * @return
180      */
181     public static boolean isExist(String filePath) {
182 
183         if (filePath == null || filePath.length() <= 0)
184             return false;
185 
186         File file = new File(filePath);
187 
188         return file.exists();
189 
190     }
191 
192     /**
193      * 判断一个目标文件是否不存在
194      * 
195      * @param filePath
196      * @return
197      */
198     public static boolean isNotExist(String filePath) {
199         return !isExist(filePath);
200     }
201 
202     public static void overwrite(String filePath, List<String> strList) {
203 
204         StringBuffer content = new StringBuffer();
205         for (String string : strList) {
206             content.append(string).append("\\n");
207         }
208 
209         overwrite(filePath, content.toString());
210 
211     }
212 }

 

4、显示结果：