IO流的学习以及统计次数最多的单词

IO流：

处理数据类型：字节流（InputStream  OutputStream）和字节流（Reader  Writer）

数据流向不同：输入流和输出流(FileInputStream   FileOutputStream)

输入流：

1. InputStream 是所有的输入字节流的父类，它是一个抽象类。
2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。
3. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

输出流：

1. OutputStream 是所有的输出字节流的父类，它是一个抽象类。
2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。
3. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流

文件输入简单案例以及异常处理：

package reserve;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;

public class Main{
    public static void main(String[] args) {

    }
    @Test
    public void test() {
        FileInputStream input=null;
        try {
            input=new FileInputStream("Test/wenjian");
            int a=-1;
            while(true)
            {
                 a=input.read();
                if(a==-1)
                    break;
                System.out.print((char)a);
            }
            System.out.println((char)a);
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        finally {
            if(input!=null)
                try {
                    input.close();//流的关闭是释放资源的操作
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
        }
    }

}

测试截图：

package  money;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

import org.junit.Test;
public class Money{
    public static void main(String[] args) {

    }
    @Test
    public void fileout() throws IOException {
        FileOutputStream file=null;
        try {
            file=new FileOutputStream("Test/money");
            file.write('a');

String string="中国你好，世界你好！";
              file.write(string.getBytes());

        } catch (FileNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            try {
                if(file!=null)
                  file.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }
}

当没有当前需要输出的文件时，系统会在你写的当前路径下创建新的文件，刷新即可看到自动创建的那个文件。

输出文件中前N个最常出现的英文单词，并将结果输入到文本文件中：

package hu;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public final class Hu {
    private Hu(){}
    public static int countStringInFile(String filename , String word){
        int counter = 0;
        try{
            FileReader fr = new FileReader(filename);
                BufferedReader br = new BufferedReader(fr);
                String line = null;
                while((line = br.readLine()) != null){
                    int index = -1;
                    while(line.length() >= word.length() && (index = line.indexOf(word)) >= 0){
                        counter++;
                        line = line.substring(index + word.length());
                    }
                }
        }catch(IOException e){
            e.printStackTrace();
        }
        return counter;
    }
    public static int countString2(String filename , String word){
    int counter = 0;
    try{
        FileReader fr = new FileReader(filename);
        BufferedReader br = new BufferedReader(fr);
        String line = null;
        int l = word.length();
        while((line = br.readLine()) != null){
            for(int i = 0 ; i <= line.length() - l; i++){
                if(line.substring(i, i + l).equals(word)){
                    counter++;
                }
            }
        }
    }catch(IOException e){
        e.printStackTrace();
    }
    return counter;
   }

    public static void main(String[] args) {
        String filename = "F:\\wenjian";
        String word = "zhuo";
        System.out.println(Hu.countStringInFile(filename, word));
    }
}