首页 专题 文章 代码 归档
Java IO基础
2020.03.13 12:09 2020.03.13 12:09

1. 什么是IO

IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。

I：Input输入，O：Output输出

  • Input指从外部读入数据到内存，例如，把文件从磁盘读取到内存，从网络读取数据到内存等等。
  • Output指把数据从内存输出到外部，例如，把数据从内存写入到文件，把数据从内存输出到网络等等。

字节流和字符流：

io默认都是直接操作字节的，多用于读取或书写二进制数据，这些类的基类为InputStream或OutputStream。

而字符流操作的是为了支持Unicode编码，用于字符国际化，一个字符占用两个字节，这些类的基类为Reader或Writer。

java的io在jdk1.1以后添加了字符流的支持，为我们直接操作字符流提供了方便。

关于字符类库和字节类库的选择

最明智的做法是尽量尝试使用Reader和Writer，一旦程序代码无法成功编译，我们就会发现自己不得不使用面向字节的类库。

根据数据的流向，流分为输入流和输出流，这里指的都是内存，内存输入为读，输出为写，I读O写。

Java提供了针对不同情况的处理流的类，以便于我们直观地进行数据操作，这些类就在java的io包之中。下面介绍java io包的类，整个io包大量应用了装饰模式。

在实际使用过程中，涉及多层套用的构造函数必然都会有自己的一个装饰模式的架构，包括被装饰类（原构建基类），装饰超类，装饰具体类，用的过程中懂得去区分理解会让你更加灵活地使用它们。

  • 节点流：文件(File)，管道(Piped)和数组(Array)（他们每个类都分别包括输入输出和字节字符四种流）
  • 处理流：其余的都是处理类，他们都是属于节点流的装饰类，下面是一个关于处理流的表格。
处理流 who 个数 装饰功能
缓冲区 Buffered开头的类 4((IO/BC四种) 可将流放在缓冲区内操作
转化流 InputStreamReader/OutputStreamWriter 2 可将字节流转化为字符流
基本类型 DataXXXStream 2(IO替换XXX) 可传输基本类型数据
对象流 ObjectXXXStream 2(IO替换XXX) 可传输对象类型数据(序列化)
打印流 PrintStream/PrintWriter 2 包含print和println的输出流
合并流 SequenceInputStream 1 可逻辑串联其他输入流
行号读入流 LineNumberReader 1 可得到一个携带行号的字符读入流
推回输入流 PushbackInputStream/PushbackReader 2 可将输入流push back或unread一个字节
字符串读写流 StringWriter/StringReader 2 可在缓冲区读写字符串

注：

  • 默认命名规则：字节流是输入输出(Input/Output)，字符流是读写(Writer/Reader)，当又有输入输出又有读写的时候，那一定是转化流(InputStreamReader/OutputStreamWriter)。
  • 默认都是操作字节，所有操作字符的类都需要先经过转化流将字节流转为字符流再使用。
  • LineNumberInputStream已过时，因为它是基于字节输入流的，而错误假定字节能充分表示字符，现已被LineNumberReader取代。
  • StringBufferInputStream已过时，因为此类未能正确地将字符转换为字节，现已被StringReader取代。
  • 这里面还有一个过滤流的概念，它也包括输入输出字节字符四种流，我在上面没有表示出来。它是一个抽象类，作为“装饰器”的接口，其中，“装饰器”为其他输入输出字符字节类提供有用功能。

2. File对象

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件，File类主要用来获取或处理与磁盘文件相关的信息，像文件名、 文件路径、访问权限和修改日期等，还可以浏览子目录层次结构。

File 类表示处理文件和文件系统的相关信息。也就是说，File 类不具有从文件读取信息和向文件写入信息的功能，它仅描述文件本身的属性。

构造方法：

  • File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
  • File(String parent,String child) 根据指定的父路径和文件路径创建一个新File对象实例
  • File(File parent,String child) 根据指定的父路径对象和文件路径创建一个新的File对象实例
public static void main(String[] args) {
    //File(String pathname)  将指定路径名转换成一个File对象
    File file = new File("D:\\1.txt");
    System.out.println(file);
    //File(String parent,String child) 根据指定的父路径和文件路径创建File对象
    File file1 = new File("D:\\a", "1.txt");
    System.out.println(file1);
    //File(File parent,String child) 根据指定的父路径对象和文件路径创建File对象
    File parent = new File("D:\\a");
    File file2 = new File(parent, "1.txt");
    System.out.println(file2);
    File file3 = new File(new File("D:\\a"), "1.txt");
    System.out.println(file3);
    /*D:\1.txt
    D:\a\1.txt
    D:\a\1.txt
    D:\a\1.txt*/
}

File类创建和删除功能

  • boolean createNewFile();指定路径不存在该文件时创建文件，返回true 否则false
  • boolean mkdir（） 当指定的单击文件夹不存在时创建文件夹并返回true 否则false
  • boolean mkdirs（） 但指定的多级文件夹在某一级文件夹不存在时，创建多级文件夹并返回true 否则false
  • boolean delete（） 删除文件或者删除单级文件夹
  • 删除文件夹，这个文件夹下面不能有其他的文件和文件夹
public static void main(String[] args) throws IOException {
    File file = new File("D:\\a\\1.txt");
    File file1 = new File("1.txt");
    boolean flag = file1.createNewFile();
    System.out.println(flag);

    File file2 = new File("b");
    boolean flag2 = file2.mkdir();
    System.out.println(flag);

    File file3 = new File("c\\d\\e");
    boolean d = file1.mkdir();
    boolean c = file1.mkdirs();
    System.out.println(d);
    System.out.println(c);
    File file4 = new File("c.txt");
    System.out.println(file4.mkdir());

    File file5 = new File("b");
    System.out.println(file2.delete());

    /*true
    true
    false
    false
    true
    true
    */
}

File类的判断功能

  • boolean exists() 判断指定路径的文件或文件夹是否为空
  • boolean isAbsolute() 判断当前路径是否是绝对路径
  • boolean isDirectory() 判断当前的目录是否存在
  • boolean isFile() 判断当前的目录是否是一个文件
  • boolean isHidden() 判断当前路径是否是一隐藏文件
public static void main(String[] args) throws IOException {

    /*判断文件是否存在*/
    File file = new File("a.txt");
    boolean newFile = file.createNewFile();
    System.out.println("newFile = " + newFile);//newFile = true
    boolean flag = file.exists();
    System.out.println(flag);//true

    /*判断文件是绝对路径*/
    File file2 = new File("D:\\a\\1.txt");
    boolean flag2 = file2.isAbsolute();
    System.out.println(flag2);//true

    /*判断是否是文件/目录*/
    File file1 = new File("1.txt");
    File b = new File("b");
    System.out.println(file1.isDirectory());//false
    System.out.println(b.isFile());//false

    /*判断是否是隐藏文件*/
    File file3 = new File("D:\\a\\1.txt");
    System.out.println(file3.isHidden());//false

}

File类的获取功能和修改名字功能

  • File getAbsoluteFile() 获取文件的绝对路径，返回File对象
  • String getAbsolutePath() 获取文件的绝对路径，返回路径的字符串
  • String getParent() 获取当前路径的父级路径，以字符串形式返回该父级路径
  • String getName() 获取文件或文件夹的名称
  • String getPath() 获取File对象中封装的路径
  • long lastModified() 以毫秒值返回最后修改时间
  • long length() 返回文件的字节数
  • boolean renameTo(File dest) 将当前File对象所指向的路径修改为指定File所指向的路径

获取文件的绝对路径，返回File对象：

File file = new File("D:\\a\\1.txt");
File file1 = new File("1.txt");
//以File对象返回的形式返回当前File对象所指向的绝对路径
System.out.println(file1.getAbsoluteFile());
//返回File对象所指向的绝对路径
System.out.println(file1.getAbsolutePath());

/*E:\Java_code\JavaseStudy\1.txt
E:\Java_code\JavaseStudy\1.txt*/

获取文件的绝对路径，返回路径的字符串：

File file = new File("D:\\a.txt");
String absolutePath = file.getAbsolutePath();
System.out.println("absolutePath = " + absolutePath);
/*absolutePath = D:\a.txt*/

获取当前路径的父级路径，以字符串形式返回该父级路径：

File file = new File("D:\\a.txt");
String parent = file.getParent();
System.out.println("parent = " + parent);
/*parent = D:\*/

获取文件或文件夹的名称：

File file = new File("D:\\a.txt");
String name = file.getName();
System.out.println("name = " + name);
/*name = a.txt*/

获取File对象中封装的路径：

File file = new File("D:\\a.txt");
String path = file.getPath();
System.out.println("path = " + path);
/*path = D:\a.txt*/

以毫秒值返回最后修改时间：

File file = new File("D:\\a.txt");
long l = file.lastModified();
System.out.println("l = " + l);
/*l = 1584069256525*/
// 文件不存在则返回0

返回文件的字节数：

File file = new File("D:\\a.txt");
long length = file.length();
System.out.println("length = " + length);
//0

将当前File对象所指向的路径修改为指定File所指向的路径：

File file = new File("D:\\a.txt");
boolean b = file.renameTo(new File("E:\\a.txt"));
System.out.println("b = " + b);
/*b = true*/
// 此操作相当于把位于D盘的文件移到E盘了

File 类的其他获取功能

  • String[] list(); 以字符串的形式返回当前路径下所有的文件和文件夹的名称
  • File[] listFile 以File对象的形式返回当前路径下的所有文件和文件夹名称
  • Static File[] listRoots() 获取计算机中的所有盘符

以字符串的形式返回当前路径下所有的文件和文件夹的名称

File file = new File("D:\\");
String[] list = file.list();
for (String s : list) {
    System.out.println("s = " + s);
}
/*s = apps
s = Program Files
s = Program Files (x86)
s = PSAutoRecover*/
// 这是我演示时，D盘所存在的文件夹

以File对象的形式返回当前路径下的所有文件和文件夹名称

File file = new File("D:\\");
File[] files = file.listFiles();
for (File file1 : files) {
    System.out.println(file1.isDirectory());//true
}

获取计算机中的所有盘符

File[] files = File.listRoots();
for (File file : files) {
    System.out.println(file);
}

3. 字节流

IO流图示：

截图-1584065894

3.1. 字节流基类

InputStream

InputStream：字节输入流基类、抽象类，是表示字节输入流的所有类的超类。

常用方法

// 从输入流中读取数据的下一个字节
abstract int read()
// 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int read(byte[] b)
// 将输入流中最多 len 个数据字节读入 byte 数组
int read(byte[] b, int off, int len)


// 跳过和丢弃此输入流中数据的 n个字节
long skip(long n)

// 关闭此输入流并释放与该流关联的所有系统资源
void close()

OutputStream

OutputStream：字节输出流基类、抽象类，是表示输出字节流的所有类的超类。

常用方法：

// 将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输出流
abstract void write(int b)

// 关闭此输出流并释放与此流有关的所有系统资源
void close()

// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()

3.2. 字节文件操作流

FileInputStream

FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。

构造方法

// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
FileInputStream(File file)
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定
FileInputStream(String name)

常用方法

// 读取f盘下该文件f://hell/test.txt
//构造方法1
InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
int i = 0;
//一次读取一个字节
while ((i = inputStream.read()) != -1) {

    // System.out.print(i + " ");// 65 66 67 68
    //为什么会输出65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。
    System.out.print((char) i + " ");// A B C D
}
//关闭IO流
inputStream.close();
// 读取f盘下该文件f://hell/test.txt
//构造方法2
InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
// 字节数组
byte[] b = new byte[2];
int i2 = 0;
//  一次读取一个字节数组
while ((i2 = inputStream2.read(b)) != -1) {

    System.out.print(new String(b, 0, i2) + " ");// AB CD
}
//关闭IO流
inputStream2.close();

注意： 一次读取一个字节数组，提高了操作效率,IO流使用完毕一定要关闭。

FileOutputStream

FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。

构造方法

// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)

常用方法：覆盖和重写了父类的的常用方法。

OutputStream outputStream = new FileOutputStream(new File("test.txt"));
// 写出数据
outputStream.write("ABCD".getBytes());
// 关闭IO流
outputStream.close();

// 内容追加写入
OutputStream outputStream2 = new FileOutputStream("test.txt", true);
// 输出换行符
outputStream2.write("\r\n".getBytes());
// 输出追加内容
outputStream2.write("hello".getBytes());
// 关闭IO流
outputStream2.close();

注意：

1、输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;

2、输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。

3.3. 字节缓冲流（高效流）

BufferedInputStream

BufferedInputStream：字节缓冲输入流，提高了读取效率。

构造方法

// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
InputStream in = new FileInputStream("test.txt");
// 字节缓存流
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {

    System.out.print(new String(bs, 0, len));
    // ABCD
    // hello
}
// 关闭流
bis.close();

BufferedOutputStream

BufferedOutputStream：字节缓冲输出流，提高了写出效率。

构造方法

// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)

常用方法

// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输出流
void write(int b)
// 刷新此缓冲的输出流
void flush()

测试：

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
// 输出换行符
bos.write("\r\n".getBytes());
// 输出内容
bos.write("Hello Android".getBytes());
// 刷新此缓冲的输出流
bos.flush();
// 关闭流
bos.close();

4. 字符流

4.1. 字符流基类

Reader

Reader:读取字符流的抽象类

常用方法

// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 跳过字符
long skip(long n)

// 关闭该流并释放与之关联的所有资源
abstract void close()

Writer

Writer:写入字符流的抽象类

常用方法

// 写入字符数组
 void write(char[] cbuf)
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
// 写入单个字符
void write(int c)
// 写入字符串
void write(String str)
// 写入字符串的某一部分
void write(String str, int off, int len)

// 将指定字符添加到此 writer
Writer append(char c)
// 将指定字符序列添加到此 writer
Writer append(CharSequence csq)
// 将指定字符序列的子序列添加到此 writer.Appendable
Writer append(CharSequence csq, int start, int end)

// 关闭此流，但要先刷新它
abstract void close()
// 刷新该流的缓冲
abstract void flush()

4.2. 字符转换流

InputStreamReader

InputStreamReader：字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

常用方法

// 创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
// 创建使用给定字符集的 InputStreamReader
InputStreamReader(InputStream in, Charset cs)
// 创建使用给定字符集解码器的 InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
// 创建使用指定字符集的 InputStreamReader
InputStreamReader(InputStream in, String charsetName)

特有方法

//返回此流使用的字符编码的名称 
String getEncoding(

测试：

//使用默认编码        
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
int len;
while ((len = reader.read()) != -1) {
    System.out.print((char) len);//爱生活，爱Android

}
reader.close();

 //指定编码 
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
int len;
while ((len = reader.read()) != -1) {
    System.out.print((char) len);//????????Android
}
reader.close();

OutputStreamWriter

OutputStreamWriter：字节流转字符流。

构造方法

// 创建使用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out)
// 创建使用给定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs)
// 创建使用给定字符集编码器的 OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
// 创建使用指定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)

特有方法

//返回此流使用的字符编码的名称 
String getEncoding()

4.3. 字符缓冲流（高效流）

BufferedReader

BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

构造方法

// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)

特有方法

// 读取一个文本行
String readLine()
//生成字符缓冲流对象
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
String str;
//一次性读取一行
while ((str = reader.readLine()) != null) {
    System.out.println(str);// 爱生活，爱Android
}

//关闭流
reader.close();

BufferedWriter

BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

构造方法

// 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out)
// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
BufferedWriter(Writer out, int sz)

特有方法

// 写入一个行分隔符
void newLine()

FileReader、FileWriter

FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。
本节阅读完毕! （分享）
二维码图片 扫描关注我们哟