2021-07-25

复习IO

字符输入流读取文件

@Test
    public void fileReaderTest01(){
        FileReader reader = null;
        try {
            //字符输入流读取文件
            //选择读取的文件
            File file = new File("hello01.txt");
            //创建字符输入流
            reader = new FileReader(file);
            //用read方法读取一次读一个字符,返回值为int,读不到字符返回-1
//            int data = reader.read();
//            //使用while循环
//            while (data!=-1){
//                System.out.println((char) data);
//                //循环读入
//                data = reader.read();
//            }
            //语法上进行修改
            int data;
            //每次判断时读取并赋值
            while ((data = reader.read())!=-1){
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

用字符输入流中重载的read方法读取文件

    @Test
    public void fileReaderTest02(){
        FileReader reader = null;
        try {
            //用字符输入流中重载的read方法读取文件
            //获得文件并创建流
            reader = new FileReader(new File("hello01.txt"));
            //用read(char[])读取
            char[] chars = new char[1024];
            int len;
            while ((len = reader.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 {
            if (reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用字符输出流写出文件

    @Test
    public void fileWriterTest01(){
        FileWriter writer = null;
        try {
            //使用字符输出流写出文件
            //创建写出的文件
            File file = new File("hello.txt");
            //创建字符输出流
            writer = new FileWriter(file);
            //写入
            //可以直接写入字符串
            writer.write("jiagnhu 烽子");
            //也可以写入一个char[]
            char[] chars = {'江','湖','烽','子','h'};
            writer.write(chars);
            writer.write(chars,1,3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer!=null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用字符输入流字符输出流复制文件

    @Test
    public void fileReaderfileWriterTest(){
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            //使用字符输入流字符输出流复制文件
            //选择读取的文件并创建输出的文件
            File file = new File("hello01.txt");
            File file1 = new File("hello03.txt");
            //创建字符输入输出流
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(file1);
            //读写操作
            char[] chars = new char[1024];
            int len;
            while ((len = fileReader.read(chars))!=-1){
                System.out.println(new String(chars,0,len));
                fileWriter.write(chars,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader!=null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用字节输入输出流实现对非文本文件的复制

 @Test
    public void fileInputStreamFileOutputStreamtest(){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //使用字节输入输出流实现对非文本文件的复制
            File file = new File("2021-07-17_104603.jpg");
            File file1 = new File("第三次复制的图片.jpg");
            //创建流
            fileInputStream = new FileInputStream(file);
            fileOutputStream = new FileOutputStream(file1);

            //复制操作
            byte[] bytes = new byte[1024];
            int len;
            while ((len = fileInputStream.read(bytes))!=-1){
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用缓冲字符流读取文本文件

 @Test
    public void BufferedReaderTest(){
        BufferedReader bufferedReader = null;
        try {
            //使用缓冲字符流读取文本文件
            File file = new File("hello01.txt");
            //创建节点流
            FileReader reader = new FileReader(file);
            //创建处理流缓冲字符流
            bufferedReader = new BufferedReader(reader);
            //读取
//            char[] chars = new char[1024];
//            int len;
//            while ((len = bufferedReader.read(chars))!=-1){
//                String str = new String(chars, 0, len);
//                System.out.println(str);
//            }
            //方式二：用readLine方法,该方法一次读一行，返回String类型
            String str;
            while ((str = bufferedReader.readLine())!=null){
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用字符输出流输出

@Test
    public void BufferedWriterTest(){
        BufferedWriter bufferedWriter = null;
        try {
            //使用字符输出流输出
            File file = new File("hello.txt");
            //创建节点流
            FileWriter fileWriter = new FileWriter(file, true);
            //创建处理流
            bufferedWriter = new BufferedWriter(fileWriter);
            //写入
            bufferedWriter.write("江湖烽子");
            //写入一个char数组
            char[] chars = {'江', '湖', '烽', '子'};
            bufferedWriter.write(chars);
            bufferedWriter.write(chars,1,2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用缓冲字符流复制文件

@Test
    public void BufferedReaderBufferWriterTest(){
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //使用缓冲字符流复制文件
            File file = new File("hello01.txt");
            File file1 = new File("hello04.txt");
            //创建节点流（使用处理流时里面必须包含相应的节点流）
            FileReader fileReader = new FileReader(file);
            FileWriter fileWriter = new FileWriter(file1);
            //创建处理流
            bufferedReader = new BufferedReader(fileReader);
            bufferedWriter = new BufferedWriter(fileWriter);
            //复制
            //读取
//            char[] chars = new char[1024];
//            int len;
//            while ((len = bufferedReader.read(chars))!=-1){
//                //输出到控制台
//                System.out.println(new String(chars,0,len));
//                //复制到文件
//                bufferedWriter.write(chars,0,len);
//            }
            //方式二：用readLine一次读一行
            String str ;
            while ((str = bufferedReader.readLine())!=null){
                System.out.println(str);
                bufferedWriter.write(str+"\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用缓冲字节流复制非文本文件

 @Test
    public void BufferedInputStreamBufferedOutputStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //使用缓冲字节流复制非文本文件
            File file = new File("2021-07-17_104603.jpg");
            File file1 = new File("第四次复制的图片.jpg");
            //创建节点流
            FileInputStream fileInputStream = new FileInputStream(file);
            FileOutputStream fileOutputStream = new FileOutputStream(file1);
            //创建处理流
            bis = new BufferedInputStream(fileInputStream);
            bos = new BufferedOutputStream(fileOutputStream);
            //复制
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes))!=-1){
                bos.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

获取文本上每个字符出现的次数

@Test
    public void test(){
        FileReader reader = null;
        FileWriter writer = null;
        try {
            //获取文本上每个字符出现的次数
            //使用字符流
            reader = new FileReader("hello.txt");
            writer = new FileWriter("hi.txt");
            //创建Map集合存储数据
            HashMap<Character, Integer> map = new HashMap<>();
            //读取数据并存入集合
            //这里要一个字符一个字符的读
            int len ;
            while ((len = reader.read())!=-1){
                char ch = (char) len;
                if (map.get(ch)==null){
                    map.put(ch,1);
                }else {
                    map.put(ch,map.get(ch)+1);
                }
            }
            //得到键值对的集合
            Set<Map.Entry<Character, Integer>> entries = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entries) {
                switch (entry.getKey()){
                    case ' ':
                        writer.write("空格="+entry.getValue());
                        break;
                    case '\t':
                        writer.write("Tab键="+entry.getValue());
                        break;
                    case '\n':
                        writer.write("换行="+entry.getValue());
                        break;
                    case '\r':
                        writer.write("回车="+entry.getValue());
                        break;
                    default:
                        writer.write(entry+"");
                }
                writer.write("\n");
                System.out.println(entry);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer!=null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }