IO流 输入和输出处理(字节流)----字节输入流

IO流 输入和输出处理(字节流 字符流)

IO流概述和分类

• Io流概述:
  • IO: 输入/输出(Input/Output)
  • 流: 是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的
    常见的应用:文件复制;文件上传;文件下载
• IO流分类:
  • 按照数据的流向
    • 输入流:读数据
    • 输出流:写数据
  • 按照数据类型来分
    • 字节流
      字节输入流;字节输出流
    • 字符流
      字符输入流;字符输出流
      一般按照数据类型来分

Java I/O

持久化保存(文件)

文件3-1

文件3-2

• File类访问文件属性
  

文件3-3

• File类常用方法

方法名称	说明
boolean exists()	判断文件或目录是否存在
boolean isFile()	判断是否是文件
boolean isDirectory()	判断是否是目录
String getPath()	返回此对象表示的文件的相对路径名
String getAbsolutePath()	返回此对象表示的文件的绝对路径名
String getName()	返回此对象表示的文件或目录的名称
boolean delete()	删除此对象指定的文件或目录
boolean createNewFile()	创建名称的空文件,不创建文件夹
long length()	返回文件的长度,单位为字节,如果文件不存在,则返回OL

示例

public class Test01 {
    public static void main(String[] args) {
        //把物理文件转换成Java中的对象 文件的路径可以存在也可以不存在
        File file=new File("D:\\test.txt");// 使用 \\ 或者 /

        System.out.println("判断文件是否存在");
        System.out.println(file.exists());

        System.out.println("判断是否是文件");
        System.out.println(file.isFile());

        System.out.println("判断是否是目录");
        System.out.println(file.isDirectory());

        System.out.println("返回此对象表示的文件的相对路径名");
        System.out.println(file.getPath());

        System.out.println("返回此对象表示的文件的绝对路径名");
        System.out.println(file.getAbsolutePath());

        System.out.println("返回此对象表示的文件或目录的名称");
        System.out.println(file.getName());

        System.out.println("删除此对象指定的文件或目录");
        System.out.println(file.delete());

        System.out.println("创建名称的空文件,不创建文件夹");
        try {
            System.out.println(file.createNewFile());
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("返回文件的长度,单位为字节,如果文件不存在,则返回OL");
        System.out.println(file.length());
    }
}

3-1 流

• 通过流来读写文件
  • 流是一组有序的数据序列
  • 以先进先出方式发送信息的通道

3-2 流

• 输入/输出流与数据源
  

先入先出

3-3

• Java流的分类
  

流（Stream）的分类方式：
1. 根据数据流动的方向，可分为输入流（InputStream）和输出流（OutputStream）。
2. 根据处理数据的单位划分，可分为字节流（InputStream和OutputStream）和字符流（Reader和Writer）。
3. 根据数据流所关联的是数据源还是其他数据流，可分为节点流（Node Stream）和处理流（Processing Stream）。节点流直接从指定的位置读或写数据，如FileInputStream和FileOutputStream；处理流则是对一个已存在的流的连接和封装，通过对所封装的流的功能调用实现数据的读/写功能，如BufferedInputStream和BufferedOutputStream。

字节流(用于处理图片)

FileInputStream

• InputStream类常用方法(输入流)

  • int read()
  • int read(byte[] b)
  • int read(byte[] b,int off,int len)
  • void close()
  • int available():可以从输入流中读取的字节数目

• 子类FileInputStream常用的构造方法

  • FileInputStream(File file)
  • FileInputStream(String name)

使用FileInputStream读文本文件

FileOutputStream

• OutputStream类常用方法(输出流)

  • void write(int c)
  • void write(byte[] buf)
  • void write(byte[] b,int off,int len)
  • void close()
  • void flush():强制把缓冲区的数据写到输入流中

• 子类FileOutputStream常用的构造方法

  • FileOutputStream(File file)
  • FileOutputStream(String name)
  • FileOutputStream(String name,boolean append)

1.前两种构造方法在向文件写数据时将覆盖文件中原有的内容
2.创建FileOutputStream实例时,如果相应的文件并不存在,则会自动创建一个空的文件

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setMaster("李伟");
        dog.setName("欧欧");
        dog.setType("狗狗");

        FileInputStream fis=null;//输入
        FileOutputStream fos=null;//输出
        //构造方法里的参数表示输出流要输出到那个文件里
        try {
            fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Job\\Demo230907\\pet.txt");
            fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Job\\Demo230907\\pet2.txt");
            byte[] b=new byte[1024];
            int i;
            //fis.read 读进数组中
            while ((i=fis.read(b))!=-1){

                //System.out.println(str);
                fos.write(b,0,i);
                //转成字符串
                String str=new String(b,0,i,"utf8");
                //初始化一个字符串str2，用于存储处理后的文本。
                String str2="\n"+str.replace("{name}",dog.getName())
                        .replace("前","后")
                        .replace("{type}",dog.getType())
                        .replace("{master}",dog.getMaster());

               // System.out.println(str2); 转为字节数组 byte[] b2=str2.getBytes();
                fos.write(str2.getBytes());


            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

使用FileOutputStream 写文本文件

• 使用FileOutputStream写文本文件的步骤与读文件的步骤有何不同?
  

字符流(多用于处理文本文件 txt word)

Reader类

• Reader类常用方法
  • int read()
  • int read(char[] c)
  • read(char[] c,int off,int len)
  • void close()
• 子类InputStreamReader常用的构造方法
  • InputStreamReader(InputStream in)
  • InputStreamReader(InputStream in,String charsetName) 有效防止乱码
    s.toCharArray();//把字符串转换成char数组

FileReader类

• FileReader类是InputStreamReader的子类
  • FileReader(File file)
  • FileReader(String name)
• 该类只能按照本地平台的字符编码来读取数据,用户不能指定其他的字符编码类型
  • System.out.println(System.getProperty(“file.encoding”));
    获得本地平台的字符编码类型

使用FileReader读取文件

• 与字节流FileInputStream类实现文本文件读取步骤类似
  • 引入相关的类

  import java.io.Reader;
  import java.io.FileReader;
  import java.io.IOExceprion;
  

  • 创建FileReader对象

  Reader fr=new FileReader("路径");
  

  • 读取文本文件的数据

  fr.read();
  

  • 关闭相关的流对象

  fr.close();
  

public class InputStreamReaderTest {
    public static void main(String[] args) throws IOException {
        // InputStreamReader 字符输入流 能防止中文乱码  是对字节输入流的再包装

        //文件输入流
        FileInputStream fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc.txt");
        //创建字符输入流对象
        InputStreamReader isr=new InputStreamReader(fis, StandardCharsets.UTF_8);
        char[] c=new char[1024];
        int i;//表示每次读到的字符数
        while ((i=isr.read(c))!=-1){
            for (int j = 0; j < i; j++) {
                System.out.println(c[j]);

            }
        }
        isr.close();
        fis.close();
    }
}

public class OutputStreamWriterTest {
    public static void main(String[] args) throws IOException {
        //创建一个字节输出流
        FileOutputStream fos=new FileOutputStream
                ("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src" +
                        "\\Learn\\Day\\Day230908\\InputStreamReader\\abcd.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        String s="今天中午吃米饭";
        // s.toCharArray();//把字符串转换成char数组
        osw.write(s);//字符输出流可以直接输出字符串
        osw.close();
        fos.close();

    }
}

BufferedReader类

• 如何提高字符流读取文本文件的效率
  • 使用FileReader类与BufferedReader类

  BufferedReader类是Reader类的子类
  BufferedReader类带有缓冲区
  按行读取内容的readLine()方法
  

• BufferedReader常用的构造方法
  • BufferedReader(Reader in)
• 子类BufferedReader特有的方法
  • readLine()

使用BufferedReader读取文本文件

• 引入相关类

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

• 构造BufferedReader对象和FileReader对象

      Reader fr=new FileReader("路径");
      BufferedReader br=new BufferedReader(fr);
  

• 调用readLine()方法读取数据

      br.readLine();
  

• 关闭文件流对象

      br.close();
      fr.close();
  

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        //创建一个字节输入流
        FileInputStream fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc.txt");
        //创建一个字符输入流
        InputStreamReader isr=new InputStreamReader(fis);
        //创建BufferReader 自带缓冲区
        BufferedReader br=new BufferedReader(isr);
        String s;
        while ((s=br.readLine())!=null){
            System.out.println(s);
        }
        br.close();
        isr.close();
        fis.close();

    }
}

public class BufferedWriterTest {
    public static void main(String[] args) {
        //创建一个字节输出流
        FileOutputStream fos=null;
        //创建一个字符输出流
        OutputStreamWriter osw=null;
        //创建BufferedWriter
        BufferedWriter bw=null;
        try {
            fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt");
            osw=new OutputStreamWriter(fos);
            bw=new BufferedWriter(osw);

            String s="今天星期五,明天星期六";
            bw.write(s);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                osw.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

工具类

package Learn.Day.Day230908.InputStreamReader.Demo01;/*
 * @Date:2023/9/8
 * @Description:Learn.Day.Day230908.InputStreamReader.Demo01
 */

import java.io.*;

public class IoUtil {//输入输出工具类

    /**
     * 读
     */
    public String input(String path) {
        //创建一个字节输入流
        FileInputStream fis = null;
        //创建一个字符输入流
        InputStreamReader isr = null;
        //创建BufferReader 自带缓冲区
        BufferedReader br = null;
        //创建字符串对象用来频繁拼接
        StringBuilder sb = new StringBuilder();
        try {
            fis = new FileInputStream(path);
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            String s;//表示读到的字符串

            while ((s = br.readLine()) != null) {
                sb = sb.append(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            try {
                br.close();
                isr.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sb.toString();
        }


    }

    /**
     * 写
     *
     * @param path    表示要输出的文件路径
     * @param message 表示要输出的内容
     */
    public void ouput(String path, String message) {
        //创建一个字节输出流
        FileOutputStream fos = null;
        //创建一个字符输出流
        OutputStreamWriter osw = null;
        //创建BufferedWriter
        BufferedWriter bw = null;
        try {
            fos = new FileOutputStream(path);
            osw = new OutputStreamWriter(fos);
            bw = new BufferedWriter(osw);

            bw.write(message);
            System.out.println("输出成功!!");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                osw.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

public class Test {
    public static void main(String[] args) {
        IoUtil ioUtil=new IoUtil();
        String s=ioUtil.input("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt");
        System.out.println(s);
        String newStr=s.replace("五","5").replace("六","6");
        ioUtil.ouput("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt",newStr);

    }
}

解决读取时中文乱码

• 读取包含中文的文本文件时,可能出现中文乱码,怎么办?

    FileReader fr=new FileReader("路径");
    BufferedReader br=new BufferedReader(fr);

    FileInputStream fis=new FileInputStream("路径");
    //使用 InoutStreamReader并设置编码格式
    InputStreamReader fr=new InputStreamReader(fis,"UTF-8");
    BufferedReader br=new BufferedReader(fr);

Writer类

• Writer类常用方法
  • Write(String str)
  • Write(String str,int off,int len)
  • void close()
  • void flush()
• 子类OutputStreamWriter常用的构造方法
  • OutputStreamWriter(OutputStream out)
  • OutputStreamWriter(OutputStream out,String charsetName)

FileWriter类

• FileWriter类是OutputStreamWriter的子类
  • FileWriter(File file)
  • FileWriter(String name)
• 该类只能按照本地平台的字符编码来写数据,用户不能指定其他的字符编码类型

FileWriter写文件

• 与字节流FileOutputStream类实现向文本文件写入数据步骤类似
  • 引入相关的类

      import java.io.Reader;
      import java.io.FileWriter;
      import java.io.IOException;
  

  • 创建FileWriter对象

  Writer fw=new FileWriter("路径");
  

  • 写文本文件

  fw.write();
  

  • 关闭相关的流对象

  fw.close();
  

BufferedWriter类

• 如何提高字符流写文本文件的效率?
  • 使用FileWriter类与BufferedWriter类

    BufferedWriter类是Writer类的子类
    BufferedWriter类带有缓冲区
    

  • BufferedWriter常用的构造方法
    • BufferedWriter(Writer out)

使用BufferedWriter写文件

• 引入相关的类

    import java.io.FileWriter;
    import java.io.BUfferedWriter;
    import java.io.IOException;

• 构造BufferedWriter对象和FileWriter对象

    FileWriter fw=new FileWriter("路径");
    BufferedWriter bw=new BufferedWriter(fw);

• 调用Writer()方法写数据

bw.writer("hello");

• 流对象的清空和关闭flush()和close()

bw.flush();
fw.close();

/*
字节缓冲流:
    BufferOutputStream
    BufferedInputStream
 构造方法:
    字节缓冲输出流: BufferedOutputStream(OutputStream out)
    字节缓冲输入流: BufferedInputStream(InputStream in)

 */
public class BuffferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流 BufferedOutputStream(OutputStream out)
//        FileOutputStream fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\DemoLin\\src\\Demo\\BufferedOutputStream\\bos.txt");
//        BufferedOutputStream bos=new BufferedOutputStream(fos);
        String path="D:\\ideaworkspace\\J3071javaoop\\DemoLin\\src\\Demo\\BufferedOutputStream\\bos.txt";
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(path));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.close();

        //字节缓冲输入流: BufferedInputStream(InputStream in)
        //读数据 一次读取一个字节数据
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(path));
//        int by;
//        while ((by=bis.read())!=-1){
//            System.out.print((char)by);
//        }


        //一次读取一个字节数组数据
        byte[] bys=new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        bis.close();
    }
}