IO流

/*
一：流的分类
1.操作数据单位：字节流，字符流
2.  数据的流向：输入流，输出流
3.流的角色：节点流，处理流
二：流的体系结构
抽象基类                 字节流                 缓冲流(处理流的一种)
InputStream             FileInputSteam         BufferedInputStream
OutputStream            FileOutputStream       BufferedOutputStream
Reader                  FileReader             BufferedReader
Writer                  FileWriter             BufferedWriter
 */
//说明点：1.read()返回读入的一个字符，如果达到文件的末尾，返回-1；
//2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
//3.读入的文件一定要存在，否则就会报FileNotFoundException

（1）相关操作

public class FileReaderWriterTest {
    @Test
    public void test() {
        FileReader fileReader=null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file=new File("hello.txt");
            //2.提供具体的流
            fileReader=new FileReader(file);
            //3.数据的读入
            //方式一:
//        int read = fileReader.read();
//        while (read!=-1){
//            System.out.print((char) read);
//            read=fileReader.read();
//        }
            //方式二：
            int read;
            while ((read=fileReader.read())!=-1){
                System.out.print((char) read);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
        finally {
          //4.流的关闭操作
            try {
                if(fileReader!=null)
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //对read()操作升级：使用read的重载方法
    @Test
    public void test2(){
        FileReader fr=null;
        try {
            //实例化file
            File file=new File("hello.txt");
            //写入流
             fr=new FileReader(file);
            //读入操作
            //read(char[] ab)返回字符个数
            char[] chars=new char[5];
            int len;
            while ((len=fr.read(chars))!=-1){
                //方式一：
                /*for (int i = 0; i <len ; i++) {
                    System.out.print(chars[i]);
                }*/
                //方式二
                String str=new String(chars,0,len);
                System.out.print(str);
            }
        }
        catch (IOException e){
            e.printStackTrace();

        }
        finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void test3() throws IOException {
        File file=new File("hello1");
        FileWriter fw=new FileWriter(file);
        fw.write("hello everyone");
        fw.write("hi,everyone" + "nihaoa");
        fw.close();
    }
    @Test
    public void test4() throws IOException {
        FileReader fr=null;
        FileWriter fw= null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile=new File("hello.txt");
            File  deatFile=new File("hello1");
            //2.创建输入流和输出流的对象
             fr=new FileReader(srcFile);
             fw=new FileWriter(deatFile,true);
            //3.数据的读入和写出操作
            char[] chars=new char[5];
            int len;//记录每次读入到chars数组中的字符个数
            while ((len=fr.read(chars))!=-1)
            {
                fw.write(chars,0,len);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
        finally {
            //4.关闭流资源
            fr.close();
            fw.close();
        }
        }


}

（2）文件的创建

public class file {
    @Test
    public void test1() throws IOException {
        File file=new File("hi.txt");
        //文件创建
        if(!file.exists()){
            file.createNewFile();
            System.out.println("创建成功");
        }
        else
        {//文件存在
            file.delete();
            System.out.println("删除成功");
        }
    }
}

//处理流之一：缓冲流的使用
/*
1.缓冲流：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
2.作用:
提供流的读取，写入的速度
 */

 

（3）BufferedInputStream,BufferedOutputStream相关操作

public class BufferedTest {
@Test
    public void BufferedStreamTest() throws IOException {
    /*
    实现非文本文件的复制
     */
    //1.造文件
    File file=new File("xueshengzheng.jpg");
    File file1=new File("xueshengzheng1");
    //2.造流
    //2.1造节点流
    FileInputStream fis=new FileInputStream(file);
    FileOutputStream fos=new FileOutputStream(file1);
    //2.2造缓冲流
    BufferedInputStream bif=new BufferedInputStream(fis);
    BufferedOutputStream bof=new BufferedOutputStream(fos);
    //3.复制的细节
    byte[] bytes=new byte[10];
    int len;
    while ((len=bif.read(bytes))!=-1){
        bof.write(bytes,0,len);
    }
    //4.资源关闭,要求：先关闭外层，再关里层
  if (bif!=null)
    bif.close();
  if (bof!=null)
    bof.close();
}
/*
使用BufferedReader和BufferedWriter实现文本文件的复制
 */
@Test
    public void testBufferReaderBufferedWriter() throws IOException {
    //1.造文件,造流
    BufferedReader br=new BufferedReader(new FileReader(new File("hello.txt")));
    BufferedWriter bw=new BufferedWriter(new FileWriter(new File("hello2.txt")));
    //2.复制的细节
    /*方式一：
    char[] chars=new char[1024];
    int len;
    while ((len=br.read(chars))!=-1){
        bw.write(chars,0,len);
        bw.flush();
    }*/
    //方式二：
    String data;
    while ((data=br.readLine())!=null)
    {
       //方法一： bw.write(data+"\n");
        bw.write(data);
        bw.newLine();
    }
    br.close();
    bw.close();

}
@Test
    public void jiamitest() throws IOException {
    FileInputStream fis=new FileInputStream(new File("xueshengzheng.jpg"));
    FileOutputStream fos=new FileOutputStream(new File("xueshengzhengscreat.jpg"));
    byte[] bytes=new byte[1024];
    int len;
    while ((len=fis.read(bytes))!=-1){
        //对数组进行加密操作
        for (int i = 0; i <len ; i++) {
        bytes[i]= (byte) (bytes[i]^5);
        }
        fos.write(bytes);
    }
    fis.close();
    fos.close();
}
}

(4.)InputStreamReader相关操作

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
//输入字符转换为大写
public class exer {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        while (true){
            System.out.println("请输入字符:");
            String data = br.readLine();
            if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                System.out.println("程序退出");
                break;
            }
            String s = data.toUpperCase();
            System.out.println(s);
        }
        br.close();
    }
}

（5）Map集合和流的操作

import org.junit.Test;

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//从文档中读出每个字符出现的次数
public class wordCount {
    @Test
    public void test() throws IOException {
        //1.创建map集合
        Map<Character,Integer> map=new HashMap<>();
        //2.遍历每一个字符，每一个字符出现的次数放到map中
        FileReader fr=new FileReader(new File("hello.txt"));
        int c=0;
        while ((c=fr.read())!=-1){
            //转换成char类型
            char ch=(char) c;
            //判断char是否在map中第一次出现
            if (map.get(ch)==null) {
                map.put(ch,1);
            }
            else
            {
                map.put(ch,map.get(ch)+1);
            }
        }
        //3.map中的数据存放在wordcount中
        //3.1创建writer
        BufferedWriter bw=new BufferedWriter(new FileWriter(new File("wordcount.txt")));
        //3.2遍历map，再写入数据
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        for (Map.Entry<Character,Integer> entry:set){
            switch (entry.getKey()){
                case ' ':
                    bw.write("空格"+entry.getValue());
                    break;
                case '\t'://表示tab键字符
                    bw.write("tab键="+entry.getValue());
                    break;
                case '\r':
                    bw.write("回车="+entry.getValue());
                    break;
                case '\n':
                    bw.write("换行="+entry.getValue());
                    break;
                default:
                    bw.write(entry.getKey()+"="+entry.getValue());
                    break;

            }
            bw.newLine();
        }
        bw.close();
        fr.close();
    }

}