IO流基础

I/O流

1.流的概念

流是一个抽象 动态的概念 是一连串连续动态的数据集合。
输入流：通过流将数据源中的数据输送到程序
输出流：通过流将程序中的数据输送到目的数据源

• 输入流
  • InputStream
    • FileInputStream
    • BufferedInputStream
    • ObjectInputStream
  • Reader
    • FileReader
    • BufferedReader
    • InputStreamReader
• 输出流
  • OutputStream
    • FileOutStream
    • BufferedOutputStream
    • ObjectOutPutStream
  • Writer
    • FileWriter
    • BufferedWriter
    • OutputStreamWriter

文件创建

public static void main(String[] args) throws IOException {
        //方式1
        String location = "d:\\news.txt";
        File file = new File(location);
        System.out.println(file.createNewFile());
        //方式2
        String location2 = "d:\\";
        File file1 = new File(location2,"news2.txt");
        file1.createNewFile();


    }

2.java中四大IO抽象类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8vnn6J7z-1665627225066)(2022-07-22-14-04-32.png)]
流的分类
按操作单位：字节流(8 bit) 字符流(字符)
按数据流向：输入流 输出流
按流的角色：节点流 处理流/包装流

该四个类都是抽象类 需要创建子类实现

2.1 字节流(stream结尾)

1. InputStram

   • InputStream是一个抽象 类，不可实例化。数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类
   • 继承自InputStream的流都是用于向程序中输入程序，且数据的单位为字节（8bit）
   • 常用方法：
   • int read():读取一个字节的数据，并将字节的值作为int类型返回（0~255之间的一个值）。如果未读出字节则返回-1（返回值-1表示读取结束）
   • long skip(long n) 跳过并从输入流中丢弃n个字节的数据
   • int read(byte[] b) 从该输入流服务区最多b.length个字节的数据为字节数组
   • int read(byte[] b, int off, int len) 从该输入流读取最多，len字节的数据为字节数组。
   • void close():关闭输入流对象，释放相关系统资源

2. OutputStream

   • 此抽象类是表示字节输出流的所有类的父类，输出流接受输出字节并将这些字节发送到某个目的地。
   • 常用方法：
   • void write(int n):向目的地中写入一个字节
   • void write(byte[] b) 将b.length个字节从指定的字节数组写入此文件输出流。
   • void write(byte[] b, int off, int len)将len字节从位于偏移量off的指定字节数组写入此文件
   • void close():关闭输出流对象，释放相关系统资源

2.2 字符流(reader或writer结尾)

1. Reader

   • Reader用于读取的字符流抽象类，数据单位为字符
   • 常用方法：
   • int read():读取一个字符的数据，并将字符的值作为int类型返回（0-65535之间的一个值，即Unicode值）。如果未读出字符则返回-1（返回-1表示读取结束）。
   • int read(char[] b) 从该输入流服务区最多b.length个字节的数据为字节数组
   • int read(char[] b, int off, int len) 从该输入流读取最多，len字节的数据为字节数组。
   • void close():关闭流对象，释放相关系统资源。

2. Writer

   • Writer用于写入的字符流抽象类，数据单位为字符
   • 常用方法：
   • void write(int n):向输出流中写入一个字符
   • write(char[] cbuf) 写入一个字符数组。
   • write(char[] cbuf, int off, int len)` 写入字符数组的一部分。
   • void close():关闭输出流对象，释放相关系统资源

2.3 节点流

节点流也被成为低级流，是可以从/向一个特定的IO设备（如磁盘、网络）读/写数据的流。

2.4 处理流

处理流也被称为高级流，处理流是对一个已存在的流进行连接或封装，通过封装后的流来实现数据读/写功能。

3.入门IO流程序

3.1字节流读取

public class IO_Demo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
            int s1 = fis.read();
            int s2 = fis.read();
            int s3 = fis.read();
            int s4 = fis.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
        }  catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.2 流的构建

public class IO_Demo2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
            StringBuilder sb = new StringBuilder();
            int temp = 0;
            while((temp = fis.read()) != -1){
                System.out.println(temp);
                sb.append((char)temp);
            }
            System.out.println(sb.toString());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fis != null){
                    fis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

4.文件字节流

4.1 文件读取

public class FileDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
        System.out.println(file.delete());
        System.out.println(file.createNewFile());
        System.out.println(file.exists());
        System.out.println(file.getName());
    }
}

4.2 文件读取与上传Demo

1. 一个一个字节读取上传（效率较低）

    public class FileDemo {
        public static void main(String[] args) throws Exception {
            FileInputStream fis = null;
            fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
            //创建文件自洁输出流对象
            FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
            File file = new File("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
            if (fos!=null){
                file.delete();
            }
            int temp=0;
            while((temp=fis.read())!=-1){
                fos.write(temp);
            }
            if (fis!=null){
                fis.close();
            }if (fos!=null){
                fos.close();
            }
        }
    }
   

4.3 利用缓冲区读取上传文件

4.3.1 方法1. 推荐使用

    public class FileDemo {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = null;
        fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
        //创建文件自洁输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
        //创建一个缓冲区
        byte[] buff = new byte[1024];
        int temp=0;
        while((temp=fis.read(buff))!=-1){
            fos.write(buff,0,temp);
        }
        fos.flush();
        if (fis!=null){
            fis.close();
        }if (fos!=null){
            fos.close();
        }
    }
    }
    ```

方法2.

一口气将文件保存在缓冲区相当于一次性读取完全部字节

public class FileDemo {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = null;
        fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
        //创建文件自洁输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
        //创建一个缓冲区
        byte[] buff = new byte[fis.available()];
        fis.read(buff);
        fos.write(buff);
        fos.flush();
        if (fis!=null){
            fis.close();
        }if (fos!=null){
            fos.close();
        }
    }
}

4.4 利用缓冲流提高读写效率

BufferedInputStream 和 BufferedOutputStream

public class FileStreamBuffer {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
        bis = new BufferedInputStream(fis);
        fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
        bos = new BufferedOutputStream(fos);
        //缓冲区中，byte数组长度默认是8192
        int temp=0;
        while((temp = bis.read())!=-1){
            bos.write(temp);
        }
        //关闭顺序:后开先关
        if (bis != null){
            bis.close();
        }if (fis != null){
            fis.close();
        }if (bos != null){
            bos.close();
        }if (fos != null){
            fos.close();
        }
    }
}

5.文件字符流

5.1 文件字符输入流

public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        try{
            fr = new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
            int temp = 0;
            while ((temp = fr.read())!=-1){
                System.out.println(temp);
                System.out.println((char)temp);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fr != null){
                    fr.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

5.2 文件字符输出流

public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        FileWriter fw2 = null;
        try {
            fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
            fw.write("文件字符流的输出文件\r\n");
            fw.write("文件字符流的输出文件222\r\n");
            fw.flush();
            fw2 = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt",true);
            fw2.write("fw2");
            fw2.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fw!=null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

5.3 使用字符流实现文本文件的拷贝

public class FileCopy {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr=new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
            fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
            char[] buffer = new char[1024];//文件字符流没有available方法创建缓冲流大小
            int temp = 0;
            while((temp=fr.read(buffer))!=-1){
                fw.write(buffer,0,temp);
            }
            fw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fr!=null){
                    fr.close();
                }
                if (fw!=null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

}

5.4 字符输入缓冲流

字符输入缓冲流 BufferedReader
字符输出缓冲流 BufferedWriter

public class BufferedReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try{
            fr = new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
            br = new BufferedReader(fr);
            String temp = "";
            while((temp=br.readLine())!=null){
                System.out.println(temp);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br!=null){
                    br.close();
                }if (fr!=null){
                    fr.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

5.5 字符输出缓冲流

BufferedWriter 在自己饿输出缓冲流中可以使用newLine()方法实现换行处理

public class BufferedWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
            bw = new BufferedWriter(fw);

            bw.write("BufferedWriterDemo");
            bw.newLine();
            bw.write("换行后第二段");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw!=null){
                    bw.close();
                }if (fw!=null){
                    fw.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

5.6 使用字符缓冲流实现文件的拷贝

public class FileCopyTools {
    public static void main(String[] args) {
        copyFile("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt","D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
    }
    public static void copyFile(String src,String des){
        FileReader fr = null;
        BufferedReader br = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(src));
            bw = new BufferedWriter(new FileWriter(des));
            String temp="";
            while((temp=br.readLine())!=null){
                bw.write(temp);
                bw.newLine();
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br!=null){
                    br.close();
                }if (fr!=null){
                    br.close();
                }if (bw!=null){
                    br.close();
                }if (fw!=null){
                    br.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

6. 字符流和字节流

文件字节流和文件字符流的区别
1、字节流 ：字节读写， 字节流(ASCII)处理二进制文件。

   可以传输音频，视频，图片，文本等，传输数据的基本单位为字节。

     InputStream OutputStream 

2、字符流：快读写 ，字符流(Unicode)处理文本文件。

 只能传输纯文本， 传输数据的基本单位为字符 。

  FileWriter FileReader 一个字符等于2个字节

IO流：
流向：
输入流 read 读
InputStream
FileInputStream
FileReader
输出流 write 写
OutputStream
FileOutputStream
FileWriter
类型
字节流（读写任意文件） 1 1 1 1 1
FileInputStream
FileOutputStream
字符流（只能读写纯文本文件）中文 4 2
FileReader
FileWriter

7.转换流

public class ConvertStrem {
    public static void main(String[] args) throws IOException {
//        InputStream is = System.in;
//        int input = is.read();//read方法返回字节，接收到ascall码
        BufferedReader br = null;
        BufferedWriter bw = null;
        br = new BufferedReader(new InputStreamReader(System.in));//将字节转化字符,BufferedReader存放字符
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
        System.out.println(System.in);
        while (true){
            String input = br.readLine();
            bw.write("您输入的是：");
            bw.flush();
            if ("exit".equals(input)){
                break;
            }
            bw.write(input);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();
    }
}

##　标准流

    public static void main(String[] args) {
        //public final static InputStream in = null
        //System.in 编译类型 InputStream 运行类型(通过getClass查看) BufferedInputStream
        //表示标准输入 键盘
        System.out.println(System.in.getClass());

        //public final static PrintStream out = null;
        //编译类型 和 运行类型 PrintStream
        //表示标准输出 显示器
        System.out.println(System.out.getClass());
    }

Properties

properties 的父类就是 hashTable

public class Properties02 {
    public static void main(String[] args) throws IOException {

        //1.创建Properties类
        Properties properties = new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("src\\com\\kk\\IO\\properties_\\pro.properties"));

        properties.list(System.out);
        String user = properties.getProperty("user");
        System.out.println("用户名："+user);
    }
}