130242014044 廖之煸 第3次实验

一、实验目的

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

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

二、实验环境

硬件： （依据具体情况填写）

软件：Java或任何一种自己熟悉的语言

三、实验内容

 

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

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

四、实验步骤：

一、面向对象程序风格

1、体系结构图：

 

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

上述的面向对象风格，将问题分解为输入（Input）对象、移位(Shifter)对象、按字母表排序(Alphabetizer)对象、输出(Output)对象。

Input:对象 进行数组的输入操作

shifter对象:move方法将数组元素依次移位，每移动一位，就添加到集合中;join方法将两个移位后生成的集合合并

alphabetizer对象: removeRepetition方法删除集合中首字母重复的元素。sort方法按首字母进行排序

Output对象:printArray和printList方法分别对数组和集合进行遍历输出操作

 ....

3、写出主要的代码

 主程序：

 1 package com.lzb.kwic2;
 2 
 3 import java.util.ArrayList;
 4 
 5 public class KWIC {
 6 
 7     public static void main(String[] args) {
 8         // TODO Auto-generated method stub
 9         //输入
10         Input input=new Input();
11         //输出
12         Output output=new Output();
13         //移位
14         Shifter shifter=new Shifter();
15         //按字母排序
16         Alphabetic alphabetic=new Alphabetic();
17         
18         System.out.println("==============输入===============");
19         String[] s1=input.inputArray();
20         String[] s2=input.inputArray();
21         
22         System.out.println("==============输入显示===============");
23         output.printArray(s1);
24         output.printArray(s2);
25         
26         System.out.println("==============输出======================");
27         ArrayList<String[]> result=shifter.join(shifter.move(s1), shifter.move(s2));
28         alphabetic.removeRepetition(result);
29         alphabetic.sort(result);
30         output.printList(result);
31     }
32 
33 }

Input类：

 1 package com.lzb.kwic2;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6  * 输入
 7  * @author Administrator
 8  *
 9  */
10 public class Input {
11     
12     /**
13      * 输入数组元素
14      * @return
15      */
16     public String[] inputArray(){
17         Scanner scanner=new Scanner(System.in);
18         System.out.println("请输入数组元素个数:");
19         int len=scanner.nextInt();
20         String[] result=new String[len];
21         for(int i=0;i<len;i++){
22             System.out.print("请输入数组的第"+(i+1)+"个元素:");
23             result[i]=scanner.next();
24         }
25         
26         return result;
27     }
28     
29 }

Shifter:类：

 1 package com.lzb.kwic2;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * 移位
 7  * @author Administrator
 8  *
 9  */
10 public class Shifter {
11     /**
12      * 将数组元素依次移位，每移动一位，就添加到集合中
13      * @param a 数组
14      * @return
15      */
16     public ArrayList<String[]> move(String[] a){
17         ArrayList<String[]> resultList = new ArrayList<String[]>();
18         String temp=null;
19         for(int i=0;i<a.length;i++){
20 
21             resultList.add(a.clone());
22             temp=a[0];
23             for(int k=0;k<a.length-1;k++){
24                 a[k]=a[k+1];
25                 if(k==a.length-2){
26                     a[a.length-1]=temp;
27                 }
28             }
29             
30         }
31         
32         return resultList;
33     }
34     
35     /**
36      * 将两个集合合并
37      * @param a  集合
38      * @param b  集合
39      * @return   合并后的集合
40      */
41     public ArrayList<String[]> join(ArrayList<String[]> a,ArrayList<String[]> b){
42         ArrayList<String[]> resultList = new ArrayList<String[]>();
43         
44         for (int i = 0; i < a.size(); i++) {
45             resultList.add(a.get(i));
46         }        
47         for (int i = 0; i < b.size(); i++) {
48             resultList.add(b.get(i));
49         }
50         
51         return resultList;
52     }
53 }

Alphabetic类：

 1 package com.lzb.kwic2;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * 按字母排序
 7  * @author Administrator
 8  *
 9  */
10 public class Alphabetic {
11     /**
12      * 除去集合中首字母重复的元素
13      * @param a  集合
14      * @return    
15      */
16     public ArrayList<String[]> removeRepetition(ArrayList<String[]> a){
17         
18         for(int i=0;i<a.size();i++){
19             for(int j=i;j<a.size()-1 ;j++){
20                 if (a.get(i)[0].charAt(0)==a.get(j+1)[0].charAt(0)) {
21                     a.remove(j+1);                    
22                 }
23             }
24         }
25         
26         return a;
27     }
28     
29     /**
30      * 根据首字母顺序进行排序
31      * @param a 集合
32      * @return
33      */
34     public ArrayList<String[]> sort(ArrayList<String[]> a){
35         String[] temp=null;
36         for (int i = 0; i < a.size(); i++) {
37             for (int j = i; j < a.size()-1; j++) {
38                 if (a.get(i)[0].charAt(0)>a.get(j+1)[0].charAt(0)) {
39                     temp=a.get(i);
40                     a.set(i, a.get(j+1));
41                     a.set(j+1, temp);
42                 }
43             }
44         }
45         
46         return a;
47     }
48 }

Output:类：

package com.lzb.kwic2;

import java.util.ArrayList;

/**
 * 输出
 * @author Administrator
 *
 */
public class Output {
    
    /**
     * 打印数组
     * @param a 数组
     */
    public void printArray(String[] a){
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
    
    /**
     * 打印集合
     * @param a 集合
     */
    public void printList(ArrayList<String[]> a){
        for(int i=0;i<a.size();i++){
            printArray(a.get(i));
        }
    }
}

4、显示结果：

 二、主程序/子程序风格

  1、体系结构图：

2.主要代码：

 

  1 package com.lzb.kwic;
  2 
  3 import java.util.ArrayList;
  4 
  5 
  6 public class KWICDemo {
  7 
  8     public static void main(String[] args) {
  9         // TODO Auto-generated method stub
 10         String[] s1={"A","AN","HELLO","WORLD","CYYY"};
 11         String[] s2={"I","AM","YODA"};
 12         
 13         
 14         System.out.println("--------------Input-------------");
 15         printArray(s1);
 16         printArray(s2);
 17         
 18         System.out.println("--------------Output-------------");
 19         
 20         ArrayList<String[]> result=join(move(s1), move(s2));
 21         removeRepetition(result);
 22         sort(result);
 23         printList(result);
 24         
 25         
 26     }
 27     
 28     /**
 29      * 打印数组
 30      * @param a 数组
 31      */
 32     public static void printArray(String[] a){
 33         for(int i=0;i<a.length;i++){
 34             System.out.print(a[i]+" ");
 35         }
 36         System.out.println();
 37     }
 38     
 39     /**
 40      * 打印集合
 41      * @param a 集合
 42      */
 43     public static void printList(ArrayList<String[]> a){
 44         for(int i=0;i<a.size();i++){
 45             printArray(a.get(i));
 46         }
 47     }
 48     
 49     
 50     /**
 51      * 将数组元素依次移位，每移动一位，就添加到集合中
 52      * @param a 数组
 53      * @return
 54      */
 55     public static ArrayList<String[]> move(String[] a){
 56         ArrayList<String[]> resultList = new ArrayList<String[]>();
 57         String temp=null;
 58         for(int i=0;i<a.length;i++){
 59 
 60             resultList.add(a.clone());
 61             temp=a[0];
 62             for(int k=0;k<a.length-1;k++){
 63                 a[k]=a[k+1];
 64                 if(k==a.length-2){
 65                     a[a.length-1]=temp;
 66                 }
 67             }
 68             
 69         }
 70         
 71         return resultList;
 72     }
 73     
 74     /**
 75      * 将两个集合合并
 76      * @param a  集合a
 77      * @param b  集合b
 78      * @return   合并后的集合
 79      */
 80     public static ArrayList<String[]> join(ArrayList<String[]> a,ArrayList<String[]> b){
 81         ArrayList<String[]> resultList = new ArrayList<String[]>();
 82         
 83         for (int i = 0; i < a.size(); i++) {
 84             resultList.add(a.get(i));
 85         }        
 86         for (int i = 0; i < b.size(); i++) {
 87             resultList.add(b.get(i));
 88         }
 89         
 90         return resultList;
 91     }
 92     
 93     /**
 94      * 除去集合中首字母重复的元素
 95      * @param a  集合a
 96      * @return    
 97      */
 98     public static ArrayList<String[]> removeRepetition(ArrayList<String[]> a){
 99         
100         for(int i=0;i<a.size();i++){
101             for(int j=i;j<a.size()-1 ;j++){
102                 if (a.get(i)[0].charAt(0)==a.get(j+1)[0].charAt(0)) {
103                     a.remove(j+1);                    
104                 }
105             }
106         }
107         
108         return a;
109     }
110     
111     /**
112      * 根据首字母顺序进行排序
113      * @param a
114      * @return
115      */
116     public static ArrayList<String[]> sort(ArrayList<String[]> a){
117         String[] temp=null;
118         for (int i = 0; i < a.size(); i++) {
119             for (int j = i; j < a.size()-1; j++) {
120                 if (a.get(i)[0].charAt(0)>a.get(j+1)[0].charAt(0)) {
121                     temp=a.get(i);
122                     a.set(i, a.get(j+1));
123                     a.set(j+1, temp);
124                 }
125             }
126         }
127         
128         return a;
129     }
130 
131 }

3.运行结果

五、实验总结

 1.明白了KIWC的操作流程，不同风格的设计优缺点

 

转载于:https://www.cnblogs.com/mybian/p/7856696.html