您现在的位置是：首页 > 数据库

当前栏目

Java-IO流

文件输出对象数据

2023-03-02 11:03:54 时间

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     *
     * 一、流的分类：
     * 1.操作数据单位：字节流、字符流
     * 2.数据的流向：输入流、输出流
     * 3.流的角色：节点流、处理流
     *
     * 二、流的体系结构
     * 抽象基类         节点流（或文件流）                               缓冲流（处理流的一种）
     * InputStream     FileInputStream   (read(byte[] buffer))        BufferedInputStream (read(byte[] buffer))
     * OutputStream    FileOutputStream  (write(byte[] buffer,0,len)  BufferedOutputStream (write(byte[] buffer,0,len) / flush()
     * Reader          FileReader (read(char[] cbuf))                 BufferedReader (read(char[] cbuf) / readLine())
     * Writer          FileWriter (write(char[] cbuf,0,len)           BufferedWriter (write(char[] cbuf,0,len) / flush()
     *
     *
     *
     */
    public class FileReaderWriterTest {
    
        public static void main(String[] args) {
            File file = new File("hello.txt");//相较于当前工程
            System.out.println(file.getAbsolutePath());
    
            File file1 = new File("day09\\hello.txt");
            System.out.println(file1.getAbsolutePath());
        }
    
        /*
        将day09下的hello.txt文件内容读入程序中，并输出到控制台
    
        说明点：
        1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
        2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
        3. 读入的文件一定要存在，否则就会报FileNotFoundException。
    
         */
        @Test
        public void testFileReader(){
            FileReader fr = null;
            try {
                //1.实例化File类的对象，指明要操作的文件
                File file = new File("hello.txt");//相较于当前Module
                //2.提供具体的流
                fr = new FileReader(file);
    
                //3.数据的读入
                //read():返回读入的一个字符。如果达到文件末尾，返回-1
                //方式一：
    //        int data = fr.read();
    //        while(data != -1){
    //            System.out.print((char)data);
    //            data = fr.read();
    //        }
    
                //方式二：语法上针对于方式一的修改
                int data;
                while((data = fr.read()) != -1){
                    System.out.print((char)data);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.流的关闭操作
    //            try {
    //                if(fr != null)
    //                    fr.close();
    //            } catch (IOException e) {
    //                e.printStackTrace();
    //            }
                //或
                if(fr != null){
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        //对read()操作升级：使用read的重载方法
        @Test
        public void testFileReader1()  {
            FileReader fr = null;
            try {
                //1.File类的实例化
                File file = new File("hello.txt");
    
                //2.FileReader流的实例化
                fr = new FileReader(file);
    
                //3.读入的操作
                //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
                char[] cbuf = new char[5];
                int len;
                while((len = fr.read(cbuf)) != -1){
                    //方式一：
                    //错误的写法
    //                for(int i = 0;i < cbuf.length;i++){
    //                    System.out.print(cbuf[i]);
    //                }
                    //正确的写法
    //                for(int i = 0;i < len;i++){
    //                    System.out.print(cbuf[i]);
    //                }
                    //方式二：
                    //错误的写法,对应着方式一的错误的写法
    //                String str = new String(cbuf);
    //                System.out.print(str);
                    //正确的写法
                    String str = new String(cbuf,0,len);
                    System.out.print(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fr != null){
                    //4.资源的关闭
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
        }
        /*
        从内存中写出数据到硬盘的文件里。
    
        说明：
        1. 输出操作，对应的File可以不存在的。并不会报异常
        2.
             File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
             File对应的硬盘中的文件如果存在：
                    如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
                    如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容
    
         */
        @Test
        public void testFileWriter() {
            FileWriter fw = null;
            try {
                //1.提供File类的对象，指明写出到的文件
                File file = new File("hello1.txt");
    
                //2.提供FileWriter的对象，用于数据的写出
                fw = new FileWriter(file,false);
    
                //3.写出的操作
                fw.write("I have a dream!\n");
                fw.write("you need to have a dream!");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.流资源的关闭
                if(fw != null){
    
                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
    
        }
    
        @Test
        public void testFileReaderFileWriter() {
            FileReader fr = null;
            FileWriter fw = null;
            try {
                //1.创建File类的对象，指明读入和写出的文件
                File srcFile = new File("hello.txt");
                File destFile = new File("hello2.txt");
    
                //不能使用字符流来处理图片等字节数据
    //            File srcFile = new File("爱情与友情.jpg");
    //            File destFile = new File("爱情与友情1.jpg");
    
    
                //2.创建输入流和输出流的对象
                fr = new FileReader(srcFile);
                fw = new FileWriter(destFile);
    
    
                //3.数据的读入和写出操作
                char[] cbuf = new char[5];
                int len;//记录每次读入到cbuf数组中的字符的个数
                while((len = fr.read(cbuf)) != -1){
                    //每次写出len个字符
                    fw.write(cbuf,0,len);
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.关闭流资源
                //方式一：
    //            try {
    //                if(fw != null)
    //                    fw.close();
    //            } catch (IOException e) {
    //                e.printStackTrace();
    //            }finally{
    //                try {
    //                    if(fr != null)
    //                        fr.close();
    //                } catch (IOException e) {
    //                    e.printStackTrace();
    //                }
    //            }
                //方式二：
                try {
                    if(fw != null)
                        fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
                try {
                    if(fr != null)
                        fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
    
        }
    
    }

package com.lxl.exer2;
    
    import org.junit.Test;
    
    import java.io.File;
    import java.io.IOException;
    
    /**
     */
    public class FileDemo {
    
        @Test
        public void test1() throws IOException {
            File file = new File("D:\\io\\io1\\hello.txt");
            //创建一个与file同目录下的另外一个文件，文件名为：haha.txt
            File destFile = new File(file.getParent(),"haha.txt");
            boolean newFile = destFile.createNewFile();
            if(newFile){
                System.out.println("创建成功！");
            }
        }
    }

package com.lxl.exer2;
    
    import org.junit.Test;
    
    import java.io.File;
    import java.io.FilenameFilter;
    /**
     * 课后练习2：判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
     *
     */
    public class FindJPGFileTest {
    
        @Test
        public void test1(){
            File srcFile = new File("d:\\code");
            
            String[] fileNames = srcFile.list();
            for(String fileName : fileNames){
                if(fileName.endsWith(".jpg")){
                    System.out.println(fileName);
                }
            }
        }
        @Test
        public void test2(){
            File srcFile = new File("d:\\code");
            
            File[] listFiles = srcFile.listFiles();
            for(File file : listFiles){
                if(file.getName().endsWith(".jpg")){
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
        /*
         * File类提供了两个文件过滤器方法
         * public String[] list(FilenameFilter filter)
         * public File[] listFiles(FileFilter filter)
    
         */
        @Test
        public void test3(){
            File srcFile = new File("d:\\code");
            
            File[] subFiles = srcFile.listFiles(new FilenameFilter() {
                
                @Override
                public boolean accept(File dir, String name) {
                    return name.endsWith(".jpg");
                }
            });
            
            for(File file : subFiles){
                System.out.println(file.getAbsolutePath());
            }
        }
        
    }

package com.lxl.exer2;
    
    import java.io.File;
    /**
     * 3. 遍历指定目录所有文件名称，包括子文件目录中的文件。
        拓展1：并计算指定目录占用空间的大小
        拓展2：删除指定文件目录及其下的所有文件
     */
    public class ListFilesTest {
    
        public static void main(String[] args) {
            // 递归:文件目录
            /** 打印出指定目录所有文件名称，包括子文件目录中的文件 */
    
            // 1.创建目录对象
            File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");
    
            // 2.打印目录的子文件
            printSubFile(dir);
        }
    
        public static void printSubFile(File dir) {
            // 打印目录的子文件
            File[] subfiles = dir.listFiles();
    
            for (File f : subfiles) {
                if (f.isDirectory()) {
        // 文件目录
                    printSubFile(f);
                } else {
        // 文件
                    System.out.println(f.getAbsolutePath());
                }
    
            }
        }
    
        // 方式二：循环实现
        // 列出file目录的下级内容，仅列出一级的话
        // 使用File类的String[] list()比较简单
        public void listSubFiles(File file) {
            if (file.isDirectory()) {
                String[] all = file.list();
                for (String s : all) {
                    System.out.println(s);
                }
            } else {
                System.out.println(file + "是文件！");
            }
        }
    
        // 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
        // 建议使用File类的File[] listFiles()
        public void listAllSubFiles(File file) {
            if (file.isFile()) {
                System.out.println(file);
            } else {
                File[] all = file.listFiles();
                // 如果all[i]是文件，直接打印
                // 如果all[i]是目录，接着再获取它的下一级
                for (File f : all) {
                    listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
                }
            }
        }
    
        // 拓展1：求指定目录所在空间的大小
        // 求任意一个目录的总大小
        public long getDirectorySize(File file) {
            // file是文件，那么直接返回file.length()
            // file是目录，把它的下一级的所有大小加起来就是它的总大小
            long size = 0;
            if (file.isFile()) {
                size += file.length();
            } else {
                File[] all = file.listFiles();// 获取file的下一级
                // 累加all[i]的大小
                for (File f : all) {
                    size += getDirectorySize(f);// f的大小;
                }
            }
            return size;
        }
    
        // 拓展2：删除指定的目录
        public void deleteDirectory(File file) {
            // 如果file是文件，直接delete
            // 如果file是目录，先把它的下一级干掉，然后删除自己
            if (file.isDirectory()) {
                File[] all = file.listFiles();
                // 循环删除的是file的下一级
                for (File f : all) {
        // f代表file的每一个下级
                    deleteDirectory(f);
                }
            }
            // 删除自己
            file.delete();
        }
    
    }

![1604514-20190625000057533-78685822.png][]

![1604514-20190625000106182-2066188022.png][]

![1604514-20190625000246335-1923809227.png][]

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     *
     * 一、流的分类：
     * 1.操作数据单位：字节流、字符流
     * 2.数据的流向：输入流、输出流
     * 3.流的角色：节点流、处理流
     *
     * 二、流的体系结构
     * 抽象基类         节点流（或文件流）                               缓冲流（处理流的一种）
     * InputStream     FileInputStream   (read(byte[] buffer))        BufferedInputStream (read(byte[] buffer))
     * OutputStream    FileOutputStream  (write(byte[] buffer,0,len)  BufferedOutputStream (write(byte[] buffer,0,len) / flush()
     * Reader          FileReader (read(char[] cbuf))                 BufferedReader (read(char[] cbuf) / readLine())
     * Writer          FileWriter (write(char[] cbuf,0,len)           BufferedWriter (write(char[] cbuf,0,len) / flush()
     *
     */
    public class FileReaderWriterTest {
    
        public static void main(String[] args) {
            File file = new File("hello.txt");//相较于当前工程
            System.out.println(file.getAbsolutePath());
    
            File file1 = new File("day09\\hello.txt");
            System.out.println(file1.getAbsolutePath());
        }
    
        /*
        将day09下的hello.txt文件内容读入程序中，并输出到控制台
    
        说明点：
        1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
        2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
        3. 读入的文件一定要存在，否则就会报FileNotFoundException。
    
         */
        @Test
        public void testFileReader(){
            FileReader fr = null;
            try {
                //1.实例化File类的对象，指明要操作的文件
                File file = new File("hello.txt");//相较于当前Module
                //2.提供具体的流
                fr = new FileReader(file);
    
                //3.数据的读入
                //read():返回读入的一个字符。如果达到文件末尾，返回-1
                //方式一：
    //        int data = fr.read();
    //        while(data != -1){
    //            System.out.print((char)data);
    //            data = fr.read();
    //        }
    
                //方式二：语法上针对于方式一的修改
                int data;
                while((data = fr.read()) != -1){
                    System.out.print((char)data);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.流的关闭操作
    //            try {
    //                if(fr != null)
    //                    fr.close();
    //            } catch (IOException e) {
    //                e.printStackTrace();
    //            }
                //或
                if(fr != null){
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        //对read()操作升级：使用read的重载方法
        @Test
        public void testFileReader1()  {
            FileReader fr = null;
            try {
                //1.File类的实例化
                File file = new File("hello.txt");
    
                //2.FileReader流的实例化
                fr = new FileReader(file);
    
                //3.读入的操作
                //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
                char[] cbuf = new char[5];
                int len;
                while((len = fr.read(cbuf)) != -1){
                    //方式一：
                    //错误的写法
    //                for(int i = 0;i < cbuf.length;i++){
    //                    System.out.print(cbuf[i]);
    //                }
                    //正确的写法
    //                for(int i = 0;i < len;i++){
    //                    System.out.print(cbuf[i]);
    //                }
                    //方式二：
                    //错误的写法,对应着方式一的错误的写法
    //                String str = new String(cbuf);
    //                System.out.print(str);
                    //正确的写法
                    String str = new String(cbuf,0,len);
                    System.out.print(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fr != null){
                    //4.资源的关闭
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
        }
        /*
        从内存中写出数据到硬盘的文件里。
    
        说明：
        1. 输出操作，对应的File可以不存在的。并不会报异常
        2.
             File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
             File对应的硬盘中的文件如果存在：
                    如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
                    如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容
    
         */
        @Test
        public void testFileWriter() {
            FileWriter fw = null;
            try {
                //1.提供File类的对象，指明写出到的文件
                File file = new File("hello1.txt");
    
                //2.提供FileWriter的对象，用于数据的写出
                fw = new FileWriter(file,false);
    
                //3.写出的操作
                fw.write("I have a dream!\n");
                fw.write("you need to have a dream!");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.流资源的关闭
                if(fw != null){
    
                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
    
        }
    
        @Test
        public void testFileReaderFileWriter() {
            FileReader fr = null;
            FileWriter fw = null;
            try {
                //1.创建File类的对象，指明读入和写出的文件
                File srcFile = new File("hello.txt");
                File destFile = new File("hello2.txt");
    
                //不能使用字符流来处理图片等字节数据
    //            File srcFile = new File("爱情与友情.jpg");
    //            File destFile = new File("爱情与友情1.jpg");
    
    
                //2.创建输入流和输出流的对象
                fr = new FileReader(srcFile);
                fw = new FileWriter(destFile);
    
    
                //3.数据的读入和写出操作
                char[] cbuf = new char[5];
                int len;//记录每次读入到cbuf数组中的字符的个数
                while((len = fr.read(cbuf)) != -1){
                    //每次写出len个字符
                    fw.write(cbuf,0,len);
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.关闭流资源
                //方式一：
    //            try {
    //                if(fw != null)
    //                    fw.close();
    //            } catch (IOException e) {
    //                e.printStackTrace();
    //            }finally{
    //                try {
    //                    if(fr != null)
    //                        fr.close();
    //                } catch (IOException e) {
    //                    e.printStackTrace();
    //                }
    //            }
                //方式二：
                try {
                    if(fw != null)
                        fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
                try {
                    if(fr != null)
                        fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
    
        }
    
    }

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * 处理流之一：缓冲流的使用
     *
     * 1.缓冲流：
     * BufferedInputStream
     * BufferedOutputStream
     * BufferedReader
     * BufferedWriter
     *
     * 2.作用：提供流的读取、写入的速度
     *   提高读写速度的原因：内部提供了一个缓冲区
     *
     * 3. 处理流，就是“套接”在已有的流的基础上。
     *
     */
    public class BufferedTest {
    
        /*
        实现非文本文件的复制
         */
        @Test
        public void BufferedStreamTest() throws FileNotFoundException {
            BufferedInputStream bis = null;
            BufferedOutputStream bos = null;
    
            try {
                //1.造文件
                File srcFile = new File("爱情与友情.jpg");
                File destFile = new File("爱情与友情3.jpg");
                //2.造流
                //2.1 造节点流
                FileInputStream fis = new FileInputStream((srcFile));
                FileOutputStream fos = new FileOutputStream(destFile);
                //2.2 造缓冲流
                bis = new BufferedInputStream(fis);
                bos = new BufferedOutputStream(fos);
    
                //3.复制的细节：读取、写入
                byte[] buffer = new byte[10];
                int len;
                while((len = bis.read(buffer)) != -1){
                    bos.write(buffer,0,len);
    
    //                bos.flush();//刷新缓冲区
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.资源关闭
                //要求：先关闭外层的流，再关闭内层的流
                if(bos != null){
                    try {
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
                if(bis != null){
                    try {
                        bis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
                //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
    //        fos.close();
    //        fis.close();
            }
    
    
    
        }
    
        //实现文件复制的方法
        public void copyFileWithBuffered(String srcPath,String destPath){
            BufferedInputStream bis = null;
            BufferedOutputStream bos = null;
    
            try {
                //1.造文件
                File srcFile = new File(srcPath);
                File destFile = new File(destPath);
                //2.造流
                //2.1 造节点流
                FileInputStream fis = new FileInputStream((srcFile));
                FileOutputStream fos = new FileOutputStream(destFile);
                //2.2 造缓冲流
                bis = new BufferedInputStream(fis);
                bos = new BufferedOutputStream(fos);
    
                //3.复制的细节：读取、写入
                byte[] buffer = new byte[1024];
                int len;
                while((len = bis.read(buffer)) != -1){
                    bos.write(buffer,0,len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.资源关闭
                //要求：先关闭外层的流，再关闭内层的流
                if(bos != null){
                    try {
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
                if(bis != null){
                    try {
                        bis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
                //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
    //        fos.close();
    //        fis.close();
            }
        }
    
        @Test
        public void testCopyFileWithBuffered(){
            long start = System.currentTimeMillis();
    
            String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
            String destPath = "C:\\Users\\Administrator\\Desktop\\03-视频.avi";
    
    
            copyFileWithBuffered(srcPath,destPath);
    
    
            long end = System.currentTimeMillis();
    
            System.out.println("复制操作花费的时间为：" + (end - start));//618 - 176
        }
    
    
        /*
        使用BufferedReader和BufferedWriter实现文本文件的复制
    
         */
        @Test
        public void testBufferedReaderBufferedWriter(){
            BufferedReader br = null;
            BufferedWriter bw = null;
            try {
                //创建文件和相应的流
                br = new BufferedReader(new FileReader(new File("dbcp.txt")));
                bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
    
                //读写操作
                //方式一：使用char[]数组
    //            char[] cbuf = new char[1024];
    //            int len;
    //            while((len = br.read(cbuf)) != -1){
    //                bw.write(cbuf,0,len);
    //    //            bw.flush();
    //            }
    
                //方式二：使用String
                String data;
                while((data = br.readLine()) != null){
                    //方法一：
    //                bw.write(data + "\n");//data中不包含换行符
                    //方法二：
                    bw.write(data);//data中不包含换行符
                    bw.newLine();//提供换行的操作
    
                }
    
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //关闭资源
                if(bw != null){
    
                    try {
                        bw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(br != null){
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
        }
    
    }

转换流：

![1604514-20190625223253301-1926257224.png][]

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * 处理流之二：转换流的使用
     * 1.转换流：属于字符流
     *   InputStreamReader：将一个字节的输入流转换为字符的输入流
     *   OutputStreamWriter：将一个字符的输出流转换为字节的输出流
     *
     * 2.作用：提供字节流与字符流之间的转换
     *
     * 3. 解码：字节、字节数组  --->字符数组、字符串
     *    编码：字符数组、字符串 ---> 字节、字节数组
     *
     *
     * 4.字符集
     *ASCII：美国标准信息交换码。
        用一个字节的7位可以表示。
     ISO8859-1：拉丁码表。欧洲码表
        用一个字节的8位表示。
     GB2312：中国的中文编码表。最多两个字节编码所有字符
     GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
     Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
     UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
    
     **/
    public class InputStreamReaderTest {
    
        /*
        此时处理异常的话，仍然应该使用try-catch-finally
        InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
         */
        @Test
        public void test1() throws IOException {
    
            FileInputStream fis = new FileInputStream("dbcp.txt");
    //        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
            //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
            InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集
    
            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
    
            isr.close();
    
        }
    
        /*
        此时处理异常的话，仍然应该使用try-catch-finally
    
        综合使用InputStreamReader和OutputStreamWriter
         */
        @Test
        public void test2() throws Exception {
            //1.造文件、造流
            File file1 = new File("dbcp.txt");
            File file2 = new File("dbcp_gbk.txt");
    
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);
    
            InputStreamReader isr = new InputStreamReader(fis,"utf-8");
            OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
    
            //2.读写过程
            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                osw.write(cbuf,0,len);
            }
    
            //3.关闭资源
            isr.close();
            osw.close();
    
    
        }
    
    
    }

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * 其他流的使用
     * 1.标准的输入、输出流
     * 2.打印流
     * 3.数据流
     *
     */
    public class OtherStreamTest {
    
        /*
        1.标准的输入、输出流
        1.1
        System.in:标准的输入流，默认从键盘输入
        System.out:标准的输出流，默认从控制台输出
        1.2
        System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。
    
        1.3练习：
        从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
        直至当输入“e”或者“exit”时，退出程序。
    
        方法一：使用Scanner实现，调用next()返回一个字符串
        方法二：使用System.in实现。System.in  --->  转换流 ---> BufferedReader的readLine()
    
         */
        public static void main(String[] args) {
            BufferedReader br = null;
            try {
                InputStreamReader isr = new InputStreamReader(System.in);
                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 upperCase = data.toUpperCase();
                    System.out.println(upperCase);
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
        }
    
        /*
        2. 打印流：PrintStream 和PrintWriter
    
        2.1 提供了一系列重载的print() 和 println()
        2.2 练习：
    
    
    
         */
    
        @Test
        public void test2() {
            PrintStream ps = null;
            try {
                FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
                // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
                ps = new PrintStream(fos, true);
                if (ps != null) {
        // 把标准输出流(控制台输出)改成文件
                    System.setOut(ps);
                }
    
    
                for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                    System.out.print((char) i);
                    if (i % 50 == 0) { // 每50个数据一行
                        System.out.println(); // 换行
                    }
                }
    
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (ps != null) {
                    ps.close();
                }
            }
    
        }
    
        /*
        3. 数据流
        3.1 DataInputStream 和 DataOutputStream
        3.2 作用：用于读取或写出基本数据类型的变量或字符串
    
        练习：将内存中的字符串、基本数据类型的变量写出到文件中。
    
        注意：处理异常的话，仍然应该使用try-catch-finally.
         */
        @Test
        public void test3() throws IOException {
            //1.
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
            //2.
            dos.writeUTF("刘建辰");
            dos.flush();//刷新操作，将内存中的数据写入文件
            dos.writeInt(23);
            dos.flush();
            dos.writeBoolean(true);
            dos.flush();
            //3.
            dos.close();
    
    
        }
        /*
        将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
    
        注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
    
         */
        @Test
        public void test4() throws IOException {
            //1.
            DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
            //2.
            String name = dis.readUTF();
            int age = dis.readInt();
            boolean isMale = dis.readBoolean();
    
            System.out.println("name = " + name);
            System.out.println("age = " + age);
            System.out.println("isMale = " + isMale);
    
            //3.
            dis.close();
    
        }
    
    }

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * 对象流的使用
     * 1.ObjectInputStream 和 ObjectOutputStream
     * 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
     *
     * 3.要想一个java对象是可序列化的，需要满足相应的要求。见Person.java
     *
     * 4.序列化机制：
     * 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种
     * 二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
     * 当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。*/
    public class ObjectInputOutputStreamTest {
    
        /*
        序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
        使用ObjectOutputStream实现
         */
        @Test
        public void testObjectOutputStream(){
            ObjectOutputStream oos = null;
    
            try {
                //1.
                oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
                //2.
                oos.writeObject(new String("我爱北京天安门"));
                oos.flush();//刷新操作
    
                oos.writeObject(new Person("王铭",23));
                oos.flush();
    
                oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
                oos.flush();
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(oos != null){
                    //3.
                    try {
                        oos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
        }
    
        /*
        反序列化：将磁盘文件中的对象还原为内存中的一个java对象
        使用ObjectInputStream来实现
         */
        @Test
        public void testObjectInputStream(){
            ObjectInputStream ois = null;
            try {
                ois = new ObjectInputStream(new FileInputStream("object.dat"));
    
                Object obj = ois.readObject();
                String str = (String) obj;
    
                Person p = (Person) ois.readObject();
                Person p1 = (Person) ois.readObject();
    
                System.out.println(str);
                System.out.println(p);
                System.out.println(p1);
    
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                if(ois != null){
                    try {
                        ois.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
    
    
        }
    
    }

package com.lxl.java;
    
    import java.io.Serializable;
    
    /**
     * Person需要满足如下的要求，方可序列化
     * 1.需要实现接口：Serializable
     * 2.当前类提供一个全局常量：serialVersionUID
     * 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性
     *   也必须是可序列化的。（默认情况下，基本数据类型可序列化）
     *
     *
     * 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
     *
     **/
    public class Person implements Serializable{
    
        public static final long serialVersionUID = 475463534532L;
    
        private String name;
        private int age;
        private int id;
        private Account acct;
    
        public Person(String name, int age, int id) {
            this.name = name;
            this.age = age;
            this.id = id;
        }
    
        public Person(String name, int age, int id, Account acct) {
            this.name = name;
            this.age = age;
            this.id = id;
            this.acct = acct;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", id=" + id +
                    ", acct=" + acct +
                    '}';
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Person(String name, int age) {
    
            this.name = name;
            this.age = age;
        }
    
        public Person() {
    
        }
    }
    
    class Account implements Serializable{
        public static final long serialVersionUID = 4754534532L;
        private double balance;
    
        @Override
        public String toString() {
            return "Account{" +
                    "balance=" + balance +
                    '}';
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        public Account(double balance) {
    
            this.balance = balance;
        }
    }

![1604514-20190626225823125-1512799785.png][]

![1604514-20190626225833331-563751021.png][]

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    /**
     * RandomAccessFile的使用
     * 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
     * 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
     *
     * 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
     *   如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
     *
     * 4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果
     *
     */
    public class RandomAccessFileTest {
    
        @Test
        public void test1() {
    
            RandomAccessFile raf1 = null;
            RandomAccessFile raf2 = null;
            try {
                //1.
                raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
                raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
                //2.
                byte[] buffer = new byte[1024];
                int len;
                while((len = raf1.read(buffer)) != -1){
                    raf2.write(buffer,0,len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //3.
                if(raf1 != null){
                    try {
                        raf1.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
                if(raf2 != null){
                    try {
                        raf2.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
        }
    
        @Test
        public void test2() throws IOException {
    
            RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
    
            raf1.seek(3);//将指针调到角标为3的位置
            raf1.write("xyz".getBytes());//
    
            raf1.close();
    
        }
        /*
        使用RandomAccessFile实现数据的插入效果
         */
        @Test
        public void test3() throws IOException {
    
            RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
    
            raf1.seek(3);//将指针调到角标为3的位置
            //保存指针3后面的所有数据到StringBuilder中
            StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
            byte[] buffer = new byte[20];
            int len;
            while((len = raf1.read(buffer)) != -1){
                builder.append(new String(buffer,0,len)) ;
            }
            //调回指针，写入“xyz”
            raf1.seek(3);
            raf1.write("xyz".getBytes());
    
            //将StringBuilder中的数据写入到文件中
            raf1.write(builder.toString().getBytes());
    
            raf1.close();
    
            //思考：将StringBuilder替换为ByteArrayOutputStream
        }
    }

![1604514-20190626230011232-626966457.png][]

![1604514-20190626230022696-836855402.png][]

![1604514-20190626230054185-207298887.png][]

![1604514-20190626230104138-2005513302.png][]

![1604514-20190626230118446-1903495886.png][]

package com.lxl.java;
    
    import org.junit.Test;
    
    import java.io.File;
    import java.nio.file.Path;
    import java.nio.file.Paths;
    
    /**
     * 1. jdk 7.0 时，引入了 Path、Paths、Files三个类。
     * 2.此三个类声明在：java.nio.file包下。
     * 3.Path可以看做是java.io.File类的升级版本。也可以表示文件或文件目录，与平台无关
     * <p>
     * 4.如何实例化Path:使用Paths.
     * static Path get(String first, String … more) : 用于将多个字符串串连成路径
     * static Path get(URI uri): 返回指定uri对应的Path路径
     */
    public class PathTest {
    
        //如何使用Paths实例化Path
        @Test
        public void test1() {
            Path path1 = Paths.get("d:\\nio\\hello.txt");//new File(String filepath)
    
            Path path2 = Paths.get("d:\\", "nio\\hello.txt");//new File(String parent,String filename);
    
            System.out.println(path1);
            System.out.println(path2);
    
            Path path3 = Paths.get("d:\\", "nio");
            System.out.println(path3);
        }
    
        //Path中的常用方法
        @Test
        public void test2() {
            Path path1 = Paths.get("d:\\", "nio\\nio1\\nio2\\hello.txt");
            Path path2 = Paths.get("hello.txt");
    
    //        String toString() ： 返回调用 Path 对象的字符串表示形式
            System.out.println(path1);
    
    //        boolean startsWith(String path) : 判断是否以 path 路径开始
            System.out.println(path1.startsWith("d:\\nio"));
    //        boolean endsWith(String path) : 判断是否以 path 路径结束
            System.out.println(path1.endsWith("hello.txt"));
    //        boolean isAbsolute() : 判断是否是绝对路径
            System.out.println(path1.isAbsolute() + "~");
            System.out.println(path2.isAbsolute() + "~");
    //        Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
            System.out.println(path1.getParent());
            System.out.println(path2.getParent());
    //        Path getRoot() ：返回调用 Path 对象的根路径
            System.out.println(path1.getRoot());
            System.out.println(path2.getRoot());
    //        Path getFileName() : 返回与调用 Path 对象关联的文件名
            System.out.println(path1.getFileName() + "~");
            System.out.println(path2.getFileName() + "~");
    //        int getNameCount() : 返回Path 根目录后面元素的数量
    //        Path getName(int idx) : 返回指定索引位置 idx 的路径名称
            for (int i = 0; i < path1.getNameCount(); i++) {
                System.out.println(path1.getName(i) + "*****");
            }
    
    //        Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
            System.out.println(path1.toAbsolutePath());
            System.out.println(path2.toAbsolutePath());
    //        Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
            Path path3 = Paths.get("d:\\", "nio");
            Path path4 = Paths.get("nioo\\hi.txt");
            path3 = path3.resolve(path4);
            System.out.println(path3);
    
    //        File toFile(): 将Path转化为File类的对象
            File file = path1.toFile();//Path--->File的转换
    
            Path newPath = file.toPath();//File--->Path的转换
    
        }
    
    
    }

转载于:https://www.cnblogs.com/LXL616/p/11066695.html

[1604514-20190625000057533-78685822.png]: /images/20211220/c04821fbfe6b469cb5c65ef0ca284b8c.png
[1604514-20190625000106182-2066188022.png]: /images/20211220/72da7b26b86f40b1a899581e03622f45.png
[1604514-20190625000246335-1923809227.png]: /images/20211220/54d39605fcee4fb68cbcde85ba6ca183.png
[1604514-20190625223253301-1926257224.png]: /images/20211220/5f481cbf40654a519ecbecd6449416f6.png
[1604514-20190626225823125-1512799785.png]: /images/20211220/3aff72bc42d94e35a9eb56e2734665d1.png
[1604514-20190626225833331-563751021.png]: /images/20211220/082dacfc4d844c528b66570df12387ef.png
[1604514-20190626230011232-626966457.png]: /images/20211220/a3a749b6414a427687ccd4ba87edb9ab.png
[1604514-20190626230022696-836855402.png]: /images/20211220/2edb65f8d61f46e9bf8e3ab627fdd764.png
[1604514-20190626230054185-207298887.png]: /images/20211220/86bba52091bb4da195ea2c129ef11dae.png
[1604514-20190626230104138-2005513302.png]: /images/20211220/87d1a786b8f34769889328f4559834a5.png
[1604514-20190626230118446-1903495886.png]: /images/20211220/d09ae8a26285455ebafe8966a7e5afe2.png

猜你喜欢

【Python从零到壹】Python的字符串详解
Java语法糖
AWS 发布 AWS Glue DataBrew，让数据可视化准备工作提速达80%
覆盖 python_如何建立一个完美的 Python 项目
super详解(java)
linux 下C++调用python返回值(python.so)
手把手教你快速将宁盾双因素认证（MFA）与 Amazon WorkSpaces 集成
Java 刷题
Java 数字黑洞
python基础===一行 Python 代码实现并行（转）
使用 NICE DCV 在 G4 实例上运行 Android 应用程序
java split 竖线 |
Python入门笔记（Python元组、字典和列表）
Java Scanner 类
基于 QuickSight 的成本可视化方案
python 五子棋 web_python实现双人五子棋（终端版）
Java 异常处理
手把手教你快速部署 Spot 实例并配置中断邮件警告
Windows环境下python2.7安装mysql-python
Java面试题

zl程序教程

当前栏目

Java-IO流

相关文章