java常用io流_Java常用工具_IO流

1. 异常

1.1 异常的概述

image.png

1.2 异常的处理方式

Java中异常的顶层父类是Throwable

finally中的语句一定会执行，即使catch中有return，finally里的代码也会执行，这就是加不加finally的区别。

image.png

image.png

package cn.case5;

public class Test4 {

public static void main(String[] args) throws Exception{

try {

show();

} catch(Exception e) {

System.out.println("hello");

}

System.out.println("看看我！");

// show();

}

public static void show() throws Exception {

int a = 10 / 0;

System.out.println("a: " + a);

}

}

2. IO流

IO流是Java中用来传输数据的方式

2.1 IO流的分类

按照流向分：输入流(读数据)、输出流(写数据)

按照操作分：

字节流(以字节为单位来操作数据)

InputStream：字节输入流的顶层抽象类

FileInputStream：普通的字节输入流

BufferedInputStream：高效的字节输入流(也叫：字节缓冲输入流)

OutputStream：字节输出流的顶层抽象类

FileOutputStream：普通的字节输出流

BufferedOutputStream：高效的字节输出流(也叫：字节缓冲输出流)

字符流：以字符为单位来操作数据

Reader：字符输入流的顶层抽象类

FileReader：普通的字符输入流

BufferedReader：高效的字符输入流(也叫：字符缓冲输入流)

Writer：字符输出流的顶层抽象类

FileWriter：普通的字符输出流

BufferedWriter：高效的字符输出流(也叫：字符缓冲输出流)

Reader和Writer，InputStream和OutputStream都是抽象类，常用的子类如下

image.png

image.png

2.2 File类

学习File类的创建、判断和获取

创建：如果文件不存在，则创建并返回true，如果存在，则不创建返回false

mkdir只能创建单级目录，若要创建多级目录使用mkdirs，实际开发中，一般只使用mkdirs，它既可以创建多级目录也可以创建单级目录

image.png

image.png

package cn.case5;

import java.io.File;

import java.io.IOException;

public class Test5 {

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

// 方法1

File file1 = new File("E:\\Download\\1.txt");

System.out.println("file1: " + file1);

// 方法2

File file2 = new File("E:\\Download", "1.txt");

System.out.println("file2: " + file2);

// 方法3

File file3 = new File("E:\\Download");

File file4 = new File(file3, "1.txt");

System.out.println("file4: " + file4);

// 返回值如下：

// file1: E:\Download\1.txt

//file2: E:\Download\1.txt

//file4: E:\Download\1.txt

System.out.println("--------------------------------------");

// 创建文件,Alt+Enter快捷键，添加抛异常

File file5 = new File("E:\\Download\\2.txt");

boolean flag1 = file5.createNewFile();

System.out.println("flag1: " + flag1);

// 创建文件夹

File file6 = new File("E:\\Download\\a");

boolean flag2 = file6.mkdir();

System.out.println("flag2: " + flag2);

// 创建多级文件夹s

File file7 = new File("E:\\Download\\a\\b\\c");

boolean flag3 = file7.mkdirs();

System.out.println("flag3: " + flag3);

System.out.println("--------------------------------------");

// 2.判断功能

System.out.println("file7是否是一个目录： " + file7.isDirectory());

System.out.println("file7是否是一个文件： " + file7.isFile());

System.out.println("file7是否存在： " + file7.exists());

System.out.println("--------------------------------------");

// 3. 获取功能

File file8 = new File("lib/1.txt");

System.out.println("绝对路径: " + file8.getAbsolutePath());

System.out.println("相对路径: " + file8.getPath());

System.out.println("文件名: " + file8.getName());

File file9 = new File("lib");

String[] names = file9.list();

System.out.println("lib文件夹下的文件(文件夹)名：");

for (String name : names) {

System.out.println(name);

}

File[] files = file9.listFiles();

System.out.println("lib文件夹下的文件(文件夹)对象：");

for (File file : files) {

System.out.println(file);

}

}

}

3. 字符流读写文件

3.1 读数据

步骤：创建字符输入流对象->读取数据->释放资源

image.png

image.png

3.2 写数据

image.png

image.png

image.png

package cn.case5;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.Writer;

public class Test6 {

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

// 创建字符输入流对象,1.txt的内容是abc

Reader reader = new FileReader("lib/1.txt");

// 读取数据,read()方法返回字符的ASCII值，读不到返回-1

int ch;

while ((ch = reader.read()) != -1) {

System.out.println(ch);

}

// 释放资源

reader.close();

System.out.println("----------------------------------");

// 创建字符输入流对象,2.txt的内容是abcdefg

Reader reader2 = new FileReader("lib/2.txt");

// 定义字符数组

char[] chs = new char[3]; // 一次读取3个字符

int len; // 返回的有效长度

while ((len = reader2.read(chs)) != -1) {

String s = new String(chs, 0, len);

System.out.println(s);

}

// 释放资源

reader2.close();

System.out.println("----------------------------------");

Writer w = new FileWriter("lib/3.txt");

// 第一种写法，一次写一个字符

// w.write('好');

// 第二种写法，一次写一个指定的字符数组

char[] chs2 = {'h','e','l','l','o'};

// w.write(chs2);

// w.write(chs2, 1, 2); // 从索引为1的字符开始，长度为2

// 第三种方法，一次写一个字符串

w.write("hello world");

w.close();

}

}

3.3 字符流拷贝文件

字符缓冲流自带缓冲区，大小默认为8192个字节，也就是16K，内部使用的是字符数组的读取方法

package cn.case5;

import java.io.*;

public class Test7 {

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

Reader reader1 = new FileReader("lib/2.txt");

Writer writer1 = new FileWriter("lib/3.txt");

int len;

while ((len = reader1.read()) != -1) {

writer1.write(len);

}

reader1.close();

writer1.close();

Reader reader2 = new FileReader("lib/2.txt");

Writer writer2 = new FileWriter("lib/4.txt");

char[] chs = new char[1024];

int len2;

while ((len2 = reader2.read(chs)) != -1) {

writer2.write(chs, 0, len2);

}

reader2.close();

writer2.close();

BufferedReader br = new BufferedReader(new FileReader("lib/2.txt"));

BufferedWriter wr = new BufferedWriter(new FileWriter("lib/5.txt"));

// 字符缓冲流自带缓冲区，大小为8192个字节，也就是16K，内部使用的是字符数组的读取方法

int len3;

while ((len3 = br.read()) != -1) {

wr.write(len3);

}

br.close();

wr.close();

// 字符缓冲流一次读写一行

BufferedReader br2 = new BufferedReader(new FileReader("lib/2.txt"));

BufferedWriter wr2 = new BufferedWriter(new FileWriter("lib/6.txt"));

// 字符缓冲流自带缓冲区，大小为8192个字节，也就是16K，内部使用的是字符数组的读取方法

String str2;

while ((str2 = br2.readLine()) != null) {

wr2.write(str2);

// 一定记得换行

wr2.newLine(); // 换行，兼容各个系统

}

br2.close();

wr2.close();

}

}

3.4 字节流拷贝文件

拷贝纯文本文件使用字符流，拷贝其他(图片，音频，视频等)使用字节流

package cn.case5;

import java.io.*;

public class Test8 {

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

// 字节流读取，一次读取一个字节

// FileInputStream fis = new FileInputStream("lib/1.jpg");

// FileOutputStream fos = new FileOutputStream("lib/2.jpg");

// int len;

// while ((len = fis.read()) != -1) {

// fos.write(len);

// }

// fis.close();

// fos.close();

// 按字节数组读取，比按照字节读取快得多

// FileInputStream fis2 = new FileInputStream("lib/1.jpg");

// FileOutputStream fos2 = new FileOutputStream("lib/3.jpg");

// byte[] b = new byte[2048];

// int len2;

// while ((len2 = fis2.read(b)) != -1) {

// fos2.write(b, 0, len2);

// }

// fis2.close();

// fos2.close();

// 按字节缓冲流读取

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/1.jpg"));

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/4.jpg"));

int len3;

while ((len3 = bis.read()) != -1) {

bos.write(len3);

}

bis.close();

bos.close();

}

}