Java之IO流【个人笔记/已完结】

2022/3/20 17:28:49

本文主要是介绍Java之IO流【个人笔记/已完结】,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

一、File

1.1 File 类概述和构造方法

File:它是文件和目录路径的抽象表示

  • 文件和目录是可以通过 File 封装成对象的
  • 其封装的并不是真正存在的文件,仅仅是个路径名。它可以是存在的,也可以是不存在的。将来是要通过具体的操作把这个路径的内容转化为具体存在的。
import javax.imageio.stream.FileCacheImageOutputStream;
import java.io.File;

public class Main {
    public static void main(String[] args) {

        //将给定路径的名字字符串转换为抽象路径名来创建新的File实例
        File f1 = new File("C:\\WayToSuccess\\ItCast\\java.txt");
        System.out.println(f1); //C:\WayToSuccess\ItCast\java.txt   证明是抽象路径的表示形式,且重写了toString()方法

        //从父路径名字字符串和子路径名字字符串创建新的File实例
        File f2 = new File("C:\\WayToSuccess\\ItCast","java.txt");
        System.out.println(f2); //C:\WayToSuccess\ItCast\java.txt

        //从父路径和子路径名字符串创建新的File实例
        File f3 = new File("C:\\WayToSuccess\\ItCast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4); //C:\WayToSuccess\ItCast\java.txt
    }
}

1.2 File 类创建功能

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //在C:\WayToSuccess\ItCast目录下创建一个文件:java.txt
        File f1 = new File("C:\\WayToSuccess\\ItCast\\java.txt");
        System.out.println(f1.createNewFile()); //true

        //在C:\WayToSuccess\ItCast目录下创建一个目录JavaSE
        File f2 = new File("C:\\WayToSuccess\\ItCast\\JavaSE");
        System.out.println(f2.mkdir()); //true

        //在C:\WayToSuccess\ItCast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("C:\\WayToSuccess\\ItCast\\JavaWEB\\HTML");
        System.out.println(f3.mkdirs());    //true
    }
}

创建结果如下:
在这里插入图片描述

1.3 File 类删除功能

绝对路径:完整的路径名,不需要任何其他信息就可以定位它所表示的文件。例如:C:\WayToSuccess\ItCast
相对路径:必须使用取自其他路径名的信息进行解释。例如:WayToSuccess\ItCast

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //当前模块目录下创建java.txt文件
        File f1 = new File("FileIO\\java.txt");
        System.out.println(f1.createNewFile());

        //删除模块目录下java.txt文件
        System.out.println(f1.delete());

        //当前模块目录下创建ItCast目录
        File f2 = new File("FileIO\\ItCast");
        System.out.println(f2.mkdir());

        //删除模块目录下ItCast目录
        System.out.println(f2.delete());

        //当前模块目录下创建ItCast目录,然后在该目录下创建一个文件java.txt
        File f3 = new File("FileIO\\ItCast");
        System.out.println(f3.mkdir());
        File f4 = new File("FileIO\\ItCast\\java.txt");
        System.out.println(f4.createNewFile());

        //删除当前模块下的目录ItCast,必须一级一级删除
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.4 File 类判断和获取功能

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("FileIO\\java.txt");

        System.out.println(f1.isDirectory());   //判断是否是目录   false
        System.out.println(f1.isFile());    //判断是否是文件   true
        System.out.println(f1.exists());    //判断存在  true

        System.out.println(f1.getAbsolutePath());   //获取绝对路径    C:\WayToSuccess\File\FileIO\java.txt
        System.out.println(f1.getPath());   //获取相对路径    FileIO\java.txt
        System.out.println(f1.getName());   //获取文件名     java.txt

        File f2 = new File("C:\\WayToSuccess\\ItCast");

        //返回目录中所有的文件和目录
        String[] strArray = f2.list();
        for (String str : strArray){
            System.out.println(str);    //java.txt  JavaSE  JavaWEB
        }

        File[] fileArray = f2.listFiles();
        for (File file : fileArray){
            /*
            C:\WayToSuccess\ItCast\java.txt
            C:\WayToSuccess\ItCast\JavaSE
            C:\WayToSuccess\ItCast\JavaWEB
         */
            System.out.println(file);   //绝对路径  重写了toString方法
            System.out.println(file.getName()); //相对路径  java.txt  JavaSE  JavaWEB
        }
    }
}

我的文件列表:
在这里插入图片描述

二、字节流

2.1 IO 流概述和分类

IO 流概述:

  • IO:输入/输出(Input/Output)
  • 流:本质是数据传输
  • IO 流就是用来处理设备间数据传输问题的

IO 流分类:
① 按照数据的流向

  • 输入流:读数据
  • 输出流:写数据

② 按照数据类型来分

  • 字节流:字节输入流、字节输出流
  • 字符流:字符输入流、字符输出流

这两种流在什么情况下使用:
用Windows自带的记事本软件打开,读得懂就用字符流,读不懂就用字节流。

2.2 字节流写数据(三种方法)

字节流抽象基类

  • InputStream:这个抽象类时表示字节输入流的所有类的超类
  • OutputStream:这个抽象类时表示字节输出流的所有类的超类
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\java.txt");

        //一次写一个字节的数据,写入的是 a(a的ASCII码为97)
        fos.write(97);  //a
        fos.write(98);  //b
        fos.write(99);  //c

        //写入字节数组
        byte[] bytes1 = {100,101,102};   //def
        fos.write(bytes1);

        //getBytes():返回字符串对应的字节数组
        byte[] bytes2 = "qwert".getBytes();
        fos.write(bytes2);  //qwert

        //bytes3字节数组,从下标1开始,写3个字节
        byte[] bytes3 = "asdfg".getBytes();
        fos.write(bytes3,1,3);  //sdf

        //IO流必须关闭!释放与此流相关的任何系统资源
        fos.close();
    }
}

2.3 字节流输入换行与追加写入

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象,有追加写入
        FileOutputStream fos = new FileOutputStream("FileIO\\java.txt",true);

        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\n".getBytes());
        }

        //追加写入,true表示允许追加写入到末尾,一刷新就会多写一遍在末尾
        FileOutputStream fos2 = new FileOutputStream("FileIO\\java.txt",true);
        for (int i = 0; i < 10; i++) {
            fos2.write("world".getBytes());
            fos2.write("\n".getBytes());
        }

        //释放资源
        fos.close();
        fos2.close();
    }
}

2.4 字节流读数据(一次读一个字节)

把文件中的数据读取在控制台输出。
注意字符类型的转换!

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("FileIO\\java.txt");

        //调用字节输入流的读取方法
        int by;
        while ( (by=fis.read()) != -1){
            System.out.print((char) by);    //不强制类型转换的话,会输出97 98 99 100 101
        }

        //释放资源
        fis.close();
    }
}

输出结果:

abcde

文本文件内容:
在这里插入图片描述

2.5 字节流复制文本文件

思路:把文件中的内容读出来(数据源),再写入新文件(目的地)。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象
        FileInputStream fis = new FileInputStream("FileIO\\java.txt");

        //c创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\Output.txt");

        //读写数据(一次只读一个,一次只写一个
        int by;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }

        //释放资源
        fis.close();
        fos.close();
    }
}

java.txt(源文件):
在这里插入图片描述

Output.txt(目标文件):

2.6 字节缓冲流

字节缓冲流:

  • BufferedOutputStream:该类实现缓冲输出流。通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每一个字节导致底层系统的调用。
  • BufferedInputStream:创建一个内部缓冲区。当从六中读取或跳过字节是,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多个字节。

为什么构造方法需要的是字节流,而不是具体的文件或者路径呢?

  • 字节缓冲流仅仅提供缓冲区,而真正的读写数据还得依靠基本的字节流对象进行操作。

写数据:

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\bos.txt");
        //创建字节缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写数据
        bos.write("Hello\n\r".getBytes());
        bos.write("World\n\r".getBytes());
        //释放资源
        bos.close();
    }
}

读数据(一次只读一个字节、一次读一个字符型数组两种方式):

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象(合并)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("FileIO\\bos.txt"));
        //一次读一个字节
        int by;
        while ( (by=bis.read()) != -1 ){
            System.out.print((char) by);
        }
        
        //一次读一个数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len=bis.read(bytes)) != -1){
            System.out.print(new String(bytes,0,len));
        }
        //释放资源
        bis.close();
    }
}

三、字符流

3.1 为什么会出现字符流

  • 字符流 = 字节流 + 编码表

汉字在存储的时候,无论选择哪种编码存储,第一个字节都是负数,所以底层操作能识别中文汉字!

3.2 编码表

按照某种规则,将字符存储到计算机中,称为编码;将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码

重点:GBK、UTF-8

小结:采用何种规则编码,就要采用对应规则解码,否则会出现乱码!!!

3.3 字符串中的编码解码问题

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String str = "中国";

        //编码
        byte[] bys1 = str.getBytes();
        System.out.println(Arrays.toString(bys1));   //[-28, -72, -83, -27, -101, -67]  三个字节表示一个汉字,这里默认为utf-8

        //指定编码
        byte[] bys2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bys2));  //[-42, -48, -71, -6]

        //解码
        String ss = new String(bys1,"UTF-8");
        System.out.println(ss); //中国
    }
}

3.4 字符流中的编码解码问题

字符流中和编码解码相关的两个类:

  • InputStreamReader
  • OutputStreamWriter
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //写入
        FileOutputStream fos = new FileOutputStream("FileIO\\osw.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        osw.write("中国");
        osw.close();

        //读取
        FileInputStream fis = new FileInputStream("FileIO\\osw.txt");
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        //一次读一个字符数据
        int ch;
        while ((ch=isr.read()) != -1){
            System.out.print((char) ch);    //中国
        }
    }
}

3.5 字符流写数据的五种方式

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Main {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("FileIO\\CharStream"));
        //写一个字符
        osw.write(97);  //a
        //刷新
        osw.flush();
        //再写一个字符
        osw.write(98);  //b

        //写一个字符数组
        char[] chs = {'a','b','c','d','e'};
        osw.write(chs); //abcde

        //写一个数组的一部分
        osw.write(chs,1,3); //bcd

        //写一个字符串
        osw.write("abcde"); //abcde

        //写一个字符串的一部分
        osw.write("abcde",1,3); //bcd

        //释放资源
        osw.close();
    }
}

3.6 字符流读数据的两种方式

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("FileIO\\bos.txt"));

        //一次读一个字符数据
        int ch1;
        while ((ch1 = isr.read()) != -1){
            System.out.print((char) ch1);
        }

        //一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }

        //释放资源
        isr.close();
    }
}

3.7 字符缓冲流

字符缓冲流:

  • BufferedWriter:将文本写入字符输出流,缓冲字符,一提供单个字符、数组和字符串的高效写入,可以指定缓冲区大小,或者可以接受默认大小。
  • BufferedReader:从字符输入流读取文本,缓冲字符,以提供字符、数组和行的高效读取,可以指定缓冲区的大小,或者可以使用默认大小。
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //字符缓冲输入流
        BufferedWriter bw = new BufferedWriter(new FileWriter("FileIO\\CharStream.txt"));
        bw.write("Hello\r\n");
        bw.write("World\r\n");
        bw.close();

        //字符缓冲输出流
        BufferedReader br = new BufferedReader(new FileReader("FileIO\\CharStream.txt"));
        //一次读一个字符数据
        int ch;
        while ((ch = br.read()) != -1){
            System.out.print((char) ch);
        }
        //一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }
        br.close();
    }
}

3.8 字符缓冲流特有功能

BufferedWriter:

  • void newLine():写一行行分隔符,行分隔符字符串由系统属性定义。
    BufferedReader:
  • public String readLine():读一行文字。结果包含行的内容的字符串,不包括任何行终止字符,如果流的结尾已经到达,则为 null。
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("FileIO\\CharStream.txt"));

        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("Hello" + i);
            bw.newLine();   //自定义换行
            bw.flush(); //刷新
        }

        //释放资源
        bw.close();

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("FileIO\\CharStream.txt"));

        //读取数据
        String line;
        while ((line=br.readLine()) != null){
            System.out.println(line);	//只读内容,不读换行符号
        }

        //释放资源
        br.close();
    }
}

3.9 IO 流小结

图 from 黑马程序员
请添加图片描述
请添加图片描述
后记:
这周有些怠惰了,学习速度慢了许多。下周不会了!继续努力!



这篇关于Java之IO流【个人笔记/已完结】的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程