java IO
File
## 1.概念
文件和目录路径名的抽象表达式
## 2.创建对象
File（String pathName）;
File file =new File("D://io//a.text");//封装一个文件路径
##3.常用方法
file.length();//获取文件的字节量
file.exists();//判断文件是否存在
file.isFile();//判断是否是一个文件
file.isDirectory();//判断是否是一个文件夹
file.getName();//获取文件名称 a.text
file.getParent();//获取父目录 D:\io
file.getAbsolutePath();//获取全路径 D:\io\a.text
file.createNewFile();//是否成功创建了新文件
file = new File("d://io//m");//封装文件夹路径
file.mkdir();//自动创建一层不存在的目录
file = new File("d://io//a//b//c");
file.mkdirs();//自动创建多层不存在的目录
file.delete();//删除文件 或者空文件夹
file = new File("d://io");//封装文件夹路径
String[] strs = file.list();//获取此文件夹下的所有文件名 并存入数组中 只是字符串
File[] files = file.listFiles();//获取每隔文件 并封装成File对象存入数组中 对象 可调用方法
3.1 递归计算 文件夹 大小
package cn.tedu.number;
import java.io.File;
import java.util.Scanner;
//这个类用来测试 递归
public class Test6_Digui {
public static void main(String[] args) {
//1、接收用户输入的文件夹路径
String path = new Scanner(System.in).nextLine();
//2、封装成File对象
File dir = new File(path);
//3、调用size()求总大小
long res = size(dir) ;
System.out.println(res);
}
//4、创建size()求总大小
public static long size(File dir) {
// 1、列出文件夹里的所有资源
File[] files = dir.listFiles() ;
// 2、拿到每个资源。开始判断
long sum = 0 ; //定义变量，记录字节量和
for (int i = 0; i < files.length; i++) {
File file = files[i] ; //file表示当前获取到的资源
if( file.isFile() ) {//是文件
// 3、判断，如果是文件，直接length()求和
sum = sum + file.length() ;
}else if( file.isDirectory() ) {//是文件夹
// 4、判断，如果是文件夹，开始重复的干 1 2 3 4 这几步。。。
sum = sum + size(file) ;//递归，因为业务开始和size方法一样了
}
}
return sum ; //把最终统计好的结果 返回给调用位置
}
}
3.2 递归 删除文件夹
package cn.tedu.number;
import java.io.File;
import java.util.Scanner;
//这个类用来测试 递归
public class Test6_Digui {
public static void main(String[] args) {
//1、接收用户输入的文件夹路径
String path = new Scanner(System.in).nextLine();
//2、封装成File对象
File dir = new File(path);
//3、调用size()求总大小
del(dir) ;
}
//4、创建size()求总大小
public static void del(File dir) {
// 1、列出文件夹里的所有资源
File[] files = dir.listFiles() ;
// 2、拿到每个资源。开始判断
for (int i = 0; i < files.length; i++) {
File file = files[i] ; //file表示当前获取到的资源
if( file.isFile() ) {//是文件
// 3、判断，如果是文件，直接删除
file.delete();
}else if( file.isDirectory() ) {//是文件夹
// 4、判断，如果是文件夹，开始重复的干 1 2 3 4 这几步。。。
del(file) ;//递归，因为业务开始和size方法一样了
}
}
dir.delete() ; //删除空文件夹
}
}
InputStream 抽象类
## 1. 是字节流读取的父类 是一个抽象类 所以不能实例化 只能实例化他的子类
子类有 FileInputStream BufferedInputStream
## 2.子类构造方法
FileInputStream(String path);
FileInputStream(File file);
BufferedInputStream(InputStream in);
File f =new File("d://io//1.text");
InputStream in =new FileInputStream(f);//参数是一个 路径 也可以是一个File对象
InputStream ino =new BufferedInputStream(new FileInputStream(f));//参数是一个InputStream类型的子类
## 3.常用方法 （父类方法）
void close()
关闭此输入流并释放与该流关联的所有系统资源。
abstract int read()
从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入 byte 数组。
//字节流读取
public static void method() {
try {
//1、创建对象 -- 参数是 文件 的路径
InputStream in = new FileInputStream("D:\\iotest\\1.txt");//触发String参数的构造
InputStream in2 = new FileInputStream(new File("D:\\iotest\\1.txt"));//触发File参数的构造
//2、开始读取
/*
* System.out.println( in.read() ); //97，由于读取到了a字符，而且read()返回值是int类型。
* System.out.println( in.read() );
* System.out.println( in.read() );
*
* System.out.println( in.read() ); //由于没有数据了，所以read()返回-1
*/
int b = 0 ; //定义变量，记录读取到的值
while( ( b = in.read() ) != -1 ) {//因为读到-1时就没数据了
System.out.println(b);
}
//3、释放资源
in.close();
// System.out.println(in.read());//Stream Closed
} catch (IOException e) {
e.printStackTrace();
}
}
字符流读取 reader 抽象类
## 1. 是字符流读取的父类 抽象类
子类有 FileReader BufferedReader 字符流只能读取文本
## 2.构造方法
FileReader(File file)
FileReader(String fileName)
BufferedReader(Reader re)
File f =new File("d://io//1.text");
Reader re =new FileReader(f);
Reader reo =new Buffered(new FileReader(f));
3.常用方法
abstract void close()
关闭该流并释放与之关联的所有资源。
int read()
读取单个字符。
int read(char[] cbuf)
将字符读入数组。
abstract int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。
int read(CharBuffer target)
试图将字符读入指定的字符缓冲区。
public class Test2_In2 {
public static void main(String[] args) {
// method();//FileReader读取
method2();//BufferedReader读取
}
public static void method2() {
try {
//1、创建对象
Reader in = new BufferedReader(new FileReader("D:\\iotest\\1.txt"));
//2、开始读取
int b = 0 ;
while( ( b = in.read() ) != -1) {
System.out.println(b);
}
//3、释放资源
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//FileReader读取
public static void method() {
try {
//1、创建对象
Reader in = new FileReader("D:\\iotest\\1.txt") ;
Reader in2 = new FileReader(new File("D:\\iotest\\1.txt")) ;
//2、开始读取
int b = 0 ; //定义变量，记录读取到的数据
while( ( b = in.read() ) != -1 ) {
System.out.println(b);
}
//3、释放资源
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
OutputStream
## 字节输出流的父类
子类有 FileOutputStream bufferedOutputStream
## 2.构造方法
FileOutputStream(String name);
FileOutputStream(File file);
FileOutputStream(File file, boolean append)
FileOutputStream(String name , boolean append)
BufferedOutputStream(OutputStream out)
OutputStream out =new FileOutputStream("d://io//a.text"); // 默认是覆盖模式
OutputStream out =new FileOutputStream("d://io//a.text",true)//在原有数据后面追加
BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream("d://io//a.text"))
3.常用方法
void close()
关闭此输出流并释放与此流有关的所有系统资源。
void flush()
刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void write(int b)
将指定的字节写入此输出流。
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//这个类用来测试 字节流写出
//总结：
//1、执行效率上：BufferedOutputStream > FileOutputStream
//2、原因是：底层维护了一个byte[] ，可以按照数组的长度一次性的向磁盘中写出一大批数据。默认的容量是8192字节量，也就是8K。
public class Test3_Out {
public static void main(String[] args) {
// method();//普通的写出流FileOutputStream
method2();//高效的写出流BufferedOutputStream
}
public static void method2() {
try {
//1、创建对象
// OutputStream out = new BufferedOutputStream(
// new FileOutputStream("D:\\iotest\\1.txt"));//覆盖
OutputStream out = new BufferedOutputStream(
new FileOutputStream("D:\\iotest\\1.txt",true));//追加
//2、开始写出
out.write(48);
out.write(48);
out.write(48);
//3、释放资源
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method() {
try {
//1、创建对象－－默认是数据覆盖模式，也可以改成追加模式，需要传入第二参数true
OutputStream out = new FileOutputStream("D:\\iotest\\1.txt");//默认覆盖
// OutputStream out = new FileOutputStream("D:\\iotest\\1.txt",true);//数据追加
// OutputStream out2 = new FileOutputStream(new File("D:\\iotest\\1.txt")) ;
//2、开始写出
out.write(49);
out.write(50);
out.write(51);
//3、释放资源
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符写出流 Writer
## 1. Writer 是字符写出流的父类
子类有 FileWriter BufferedWriter
## 2.构造方法
FileWriter(File file)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)
FileWriter(File file, boolean append)
BufferedWriter(Writer out)
## 3. 测试案例
package cn.tedu.io;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
//这个类用来测试 字符流写出
//总结：
//1、执行效率上：BufferedWriter > FileWriter
//2、原因是：底层维护了一个char[] ，可以按照数组的长度一次性的向磁盘中写出一大批数据。默认的容量是8192字节量，也就是8K。
public class Test4_Out2 {
public static void main(String[] args) {
// method(); //FileWriter写出
method2(); //BufferedWriter写出
}
public static void method2() {
try {
//1、创建对象
Writer out = new BufferedWriter(new FileWriter("D:\\iotest\\1.txt"));
//2、开始写出
out.write("hello");
//3、释放资源
// out.flush();//用来把缓冲区的数据刷到磁盘中做展示
out.close();//1、把数据刷出去 2、关闭资源
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method() {
try {
//1、创建对象
// Writer out = new FileWriter("D:\\iotest\\1.txt") ;//覆盖
Writer out = new FileWriter("D:\\iotest\\1.txt",true) ;//追加
// Writer out2 = new FileWriter(new File("D:\\iotest\\1.txt")) ;
//2、开始写出
out.write(48);
out.write(48);
//3、释放资源
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试案例 文件复制
try{
InputStream in =new BufferedInputStream(new FileInputStream("D://io//a.text"));
OutputStream out = new BufferedOutputStream(new FileOutputStream("D://io//b.text"));
int b =0;//定义变量 记录读取到的数据
while（(b = in.read()) != -1）{
out.write(b);//把读取到的数据写出
}
}finally{
//释放资源
in.close();
out.close();
}
序列化/反序列化
## 1.概述
常用于服务器之间 java对象的数据传输，序列化成文件永久保存 ，反序列化读取数据恢复成java对象
序列化是指把程序中的java对象输出，永久保存到磁盘中，方便用来在多个服务器之间传输
---需要使用ObjectOutputStream 完成序列化
void writeObject(Object obj)
反序列化是指 将序列化好的文件恢复成java对象
--需要使用ObjectInputStream完成反序列化
void readObject();
## 2.测试
Student stu =new Student();
//创建序列化对象
ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream("d://io//1.text"));
//开始序列化
out.writeObject(stu);
//释放资源
out.close();
//======================================================
ObjectInputStream in =new ObjectInputStream(new FileInputStream("d://io//1.text"));
Object obj =in.readObject();
in.close();
编码流转化 解决字符流读写时的乱码现象
1. 概述
乱码 是由于保存时使用的码表 和读取时使用的码表不一致造成的
需要用到 OutputStreamWriter 和 InputStreamReader 来指定码表
2.测试
OutputStream out = new FileOutputStream("d://io//a.text");// 提供字节流
//2.通过桥梁 OutputStreamWriter 将字节转成字符 顺便指定码表
Writer out2 = new BufferedWriter(new OutputStreamObject(out,"utf-8"));
out2.write("大家好 ，我是 XXXX");
out2.close();
IO 读一行 写一行
——BufferedReader 中的readLine(); 专门用来读取一行数据
——PrintWriter 中的 println（ ）；转门用来 写出一行数据
### 测试案例
package cn.tedu.tickets;
import java.io.*;
//读取一行写出一行
public class Test5_IO {
public static void main(String[] args) throws IOException {
//1、创建读取流对象，负责一行一行读取
BufferedReader in = new BufferedReader(
new FileReader("D:\\iotest\\1.txt"));
//2、创建写出流对象，负责一行一行写出
PrintWriter out = new PrintWriter(
new FileWriter("D:\\iotest\\22.txt") ) ;
//3、读一行写一行
String line;//保存读取到的一行数据，readLine()如果没有读取到就是null
while ( ( line = in.readLine() ) != null ){
//println()把读取到的数据line一行一行写出
out.println(line);
}
//4、释放资源
in.close();
out.close();
}
}