文本处理

---

2016/1/13 星期三

弄了好几天的预处理，一直在读取文件那里挣扎，我要弄的是从一个文件夹目录下读取几个字文件夹的文本文档，过滤提取出含有某些关键词的文本，然后分别生成两个文件夹，一个是存储对过滤出来的文本进行预处理后的文本，另一个是存储过滤出来的文本的复制文本。原以为已经弄好了（原以为~~），昨晚偶然发现文件读取还是出错了~~通过不断调试代码以及师兄的帮忙，得到以下的东西~~

字节流与字符流

FileInputStream ：以字节流方式读取；
FileReader ：把文件转换为字符流读入；
InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。
Reader读取出来的是char数组或String/StringBuffer，InputStream读取出来的是byte数组。
而InputStreamReader是reader和stream之间的桥梁，可以将stream转换成字符流方式
FileInputStream 类以二进制输入 / 输出，它的 read （）方法读到的是一个字节；
FileReader 类以文本格式输入/ 输出，可以使用 while((ch = filereader.read())!=-1 ) 循环来读取文件，可以使用BufferedReader 的 readLine() 方法一行一行的读取文本。
读写文本文件的时候，采用 Reader 是非常方便的，比如 FileReader ， InputStreamReader 和 BufferedReader 。
其中最重要的类是 InputStreamReader ，它是字节转换为字符的桥梁。
但FileReader 与 InputStreamReader 涉及编码转换 ( 指定编码方式或者采用 os 默认编码 ) ，可能在不同的平台上出现乱码现象！
而 FileInputStream 以二进制方式处理，不会出现乱码现象。
如果处理纯文本文件，建议使用 FileReader ，但是要注意编码问题；
处理非纯文本文件，FileInputStream是唯一的选择。

常用方法：

（网上的代码）
Stream

private static void customBufferBufferedStreamCopy(File source, File target) {  
    InputStream fis = null;  
    OutputStream fos = null;  
    try {  
        fis = new BufferedInputStream(new FileInputStream(source));  
        fos = new BufferedOutputStream(new FileOutputStream(target));  
        byte[] buf = new byte[4096];  
        int i;  
        while ((i = fis.read(buf)) != -1) {  
            fos.write(buf, 0, i);  
        }  
    }  
    catch (Exception e) {  
        e.printStackTrace();  
    } finally {  
        close(fis);  
        close(fos);  
    }  
}  

Reader

public void readFile01() throws IOException {
        FileReader fr=new FileReader("E:/123.txt");
        BufferedReader br=new BufferedReader(fr);
        String line="";
        String[] arrs=null;
        while ((line=br.readLine())!=null) {
            arrs=line.split(",");
            System.out.println(arrs[0] + " : " + arrs[1] + " : " + arrs[2]);
        }
        br.close();
        fr.close();
    }

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。

文件的编码，系统的编码，java的默认编码有冲突
用FileReader这些类来读取系统文件，它调用的字符编码是java默认的UTF-8，但是一般WINDOW的TXT默认是ANSI，而自己本机的中文编码是GBK

所以读取数据就会出现代码，示例代码如下：

BufferedReader reader = new BufferedReader(new FileReader(file));

这是编码问题，所以要转换字符编码，但FileReader构造函数和方法成员都没有设置编码方法

而InputStreamReader类有，因此可以转换字符编码，代码如下：

BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file),"GBK"));

转换之后就可以正常读取文本中的数据，不会出现中文乱码

按行读取文本和整篇文本的读取
（在这里，真的非常感谢子旋师兄的帮忙啊啊啊，几分钟两行代码就解决了困扰我一早上的问题，不，正确来说，是好几天！！！）

ArrayList<String> mfiles = new ArrayList<String>();
        StringBuffer sb = new StringBuffer();//StringBuffer可以动态增删，String不可以
        while ((line = srcFileBR1.readLine()) != null) {
            sb.append(line);//sb.toString()后就能获取整篇文本的内容并为字符串类型，要是想要一行一行地读取，然后获取每行的字符串，就可以把这行代码删掉
            mfiles.add(line + "\r\n");//读取每行，并存进数组列表
        }

关键字过滤
垃圾邮件过滤中会用到关键字过滤：
用户预先设置一组关键字和对应的过滤规则。当接收邮件时，系统自动检查邮件的标题或内容，看其中是否含有用户设置的关键字，如果有，则根据过滤规则进行相应的操作，如拒收，或者删除，或者投递到指定目录等。这种方法误判率也很高，但它除了用来反垃圾邮件之外，还可以实现邮件自动分类等功能，所以应用很广泛。
因此，借用这种方式，从网上借鉴了代码实现了~（我是渣渣不会打代码~哭晕了~~）

package edu.stanford.nlp;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Description: 初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型
 * 
 */
public class SensitiveWordInit {
    private String ENCODING = "GBK";    //字符编码
    @SuppressWarnings("rawtypes")
    public HashMap sensitiveWordMap;

    public SensitiveWordInit(){
        super();
    }

    @SuppressWarnings("rawtypes")
    public Map initKeyWord(){
        try {
            //读取敏感词库
            Set<String> keyWordSet = readSensitiveWordFile();
            //将敏感词库加入到HashMap中
            addSensitiveWordToHashMap(keyWordSet);
            //spring获取application，然后application.setAttribute("sensitiveWordMap",sensitiveWordMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sensitiveWordMap;
    }

    /**
     * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：
     * @param keyWordSet  敏感词库
     *
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void addSensitiveWordToHashMap(Set<String> keyWordSet) {
        sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感词容器，减少扩容操作
        String key = null;  
        Map nowMap = null;
        Map<String, String> newWorMap = null;
        //迭代keyWordSet
        Iterator<String> iterator = keyWordSet.iterator();
        while(iterator.hasNext()){
            key = iterator.next();    //关键字
            nowMap = sensitiveWordMap;
            for(int i = 0 ; i < key.length() ; i++){
                char keyChar = key.charAt(i);       //转换成char型
                Object wordMap = nowMap.get(keyChar);       //获取

                if(wordMap != null){        //如果存在该key，直接赋值
                    nowMap = (Map) wordMap;
                }
                else{     //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
                    newWorMap = new HashMap<String,String>();
                    newWorMap.put("isEnd", "0");     //不是最后一个
                    nowMap.put(keyChar, newWorMap);
                    nowMap = newWorMap;
                }

                if(i == key.length() - 1){
                    nowMap.put("isEnd", "1");    //最后一个
                }
            }
        }
    }

    /**
     * 读取敏感词库中的内容，将内容添加到set集合中
     * @throws Exception 
     */
    @SuppressWarnings("resource")
    private Set<String> readSensitiveWordFile() throws Exception{
        Set<String> set = null;

        File file = new File("D:\\SensitiveWord.txt");    //读取文件
        InputStreamReader read = new InputStreamReader(new FileInputStream(file),ENCODING);
        try {
            if(file.isFile() && file.exists()){      //文件流是否存在
                set = new HashSet<String>();
                BufferedReader bufferedReader = new BufferedReader(read);
                String txt = null;
                while((txt = bufferedReader.readLine()) != null){    //读取文件，将文件内容放入到set中
                    set.add(txt);
                }
            }
            else{         //不存在抛出异常信息
                throw new Exception("敏感词库文件不存在");
            }
        } catch (Exception e) {
            throw e;
        }finally{
            read.close();     //关闭文件流
        }
        return set;
    }
}

package edu.stanford.nlp;

import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Description: 敏感词过滤
 */
public class SensitivewordFilter {
    @SuppressWarnings("rawtypes")
    private Map sensitiveWordMap = null;
    public static int minMatchTYpe = 1;      //最小匹配规则
    public static int maxMatchType = 2;      //最大匹配规则

    /**
     * 构造函数，初始化敏感词库
     */
    public SensitivewordFilter(){
        sensitiveWordMap = new SensitiveWordInit().initKeyWord();
    }

    /**
     * 判断文字是否包含敏感字符
     * @param matchType  匹配规则 1：最小匹配规则，2：最大匹配规则
     * @return 若包含返回true，否则返回false
     */
    public boolean isContaintSensitiveWord(String txt,int matchType){
        boolean flag = false;
        for(int i = 0 ; i < txt.length() ; i++){
            int matchFlag = this.CheckSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
            if(matchFlag > 0){    //大于0存在，返回true
                flag = true;
            }
        }
        return flag;
    }

    /**
     * 获取文字中的敏感词
     * @param matchType 匹配规则&nbsp;1：最小匹配规则，2：最大匹配规则
     * @return
     */
    public Set<String> getSensitiveWord(String txt , int matchType){
        Set<String> sensitiveWordList = new HashSet<String>();

        for(int i = 0 ; i < txt.length() ; i++){
            int length = CheckSensitiveWord(txt, i, matchType);    //判断是否包含敏感字符
            if(length > 0){    //存在,加入list中
                sensitiveWordList.add(txt.substring(i, i+length));
                i = i + length - 1;    //减1的原因，是因为for会自增
            }
        }

        return sensitiveWordList;
    }

    /**
     * 替换敏感字字符
     * @param matchType
     * @param replaceChar 替换字符，默认*
     * @version 1.0
     */
    public String replaceSensitiveWord(String txt,int matchType,String replaceChar){
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt, matchType);     //获取所有的敏感词
        Iterator<String> iterator = set.iterator();
        String word = null;
        String replaceString = null;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceString = getReplaceChars(replaceChar, word.length());
            resultTxt = resultTxt.replaceAll(word, replaceString);
        }

        return resultTxt;
    }

    /**
     * 获取替换字符串
     * @param replaceChar
     * @param length
     * @return
     */
    private String getReplaceChars(String replaceChar,int length){
        String resultReplace = replaceChar;
        for(int i = 1 ; i < length ; i++){
            resultReplace += replaceChar;
        }

        return resultReplace;
    }

    /**
     * 检查文字中是否包含敏感字符，检查规则如下：
     * @param beginIndex
     * @param matchType
     * @return，如果存在，则返回敏感词字符的长度，不存在返回0
     * @version 1.0
     */
    @SuppressWarnings({ "rawtypes"})
    public int CheckSensitiveWord(String txt,int beginIndex,int matchType){
        boolean  flag = false;    //敏感词结束标识位：用于敏感词只有1位的情况
        int matchFlag = 0;     //匹配标识数默认为0
        char word = 0;
        Map nowMap = sensitiveWordMap;
        for(int i = beginIndex; i < txt.length() ; i++){
            word = txt.charAt(i);
            nowMap = (Map) nowMap.get(word);     //获取指定key
            if(nowMap != null){     //存在，则判断是否为最后一个
                matchFlag++;     //找到相应key，匹配标识+1 
                if("1".equals(nowMap.get("isEnd"))){       //如果为最后一个匹配规则,结束循环，返回匹配标识数
                    flag = true;       //结束标志位为true   
                    if(SensitivewordFilter.minMatchTYpe == matchType){    //最小规则，直接返回,最大规则还需继续查找
                        break;
                    }
                }
            }
            else{     //不存在，直接返回
                break;
            }
        }
        if(matchFlag < 2 || !flag){        //长度必须大于等于1，为词 
            matchFlag = 0;
        }
        return matchFlag;
    }

    public static void main(String[] args) throws IOException {
//      SensitivewordFilter filter = new SensitivewordFilter();
//      System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());
//      String string = "Vietnam China's south China sea dispute Viet Nam ";
//      System.out.println("待检测语句字数：" + string.length());
//      long beginTime = System.currentTimeMillis();
//      Set<String> set = filter.getSensitiveWord(string, 1);
//      long endTime = System.currentTimeMillis();
//      System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);
//      System.out.println("总共消耗时间为：" + (endTime - beginTime));

    }
}

哈哈哈，今天就先这样啦~要是接下来继续有收获的话可能就继续更新，不然，本宝宝就要滚蛋啦啦啦啦~